//Created By: Leslie G. Baliguat, Created On: 01/12/2017
public Entity FilterInvoice(Entity gvdReport)
{
_tracingService.Trace("Started FilterInvoice Method..");
var dateFrom = gvdReport.Contains("gsc_datefrom")
? gvdReport.GetAttributeValue <DateTime>("gsc_datefrom").AddHours(8).ToShortDateString()
: String.Empty;
var dateTo = gvdReport.Contains("gsc_dateto")
? gvdReport.GetAttributeValue <DateTime>("gsc_dateto").AddHours(8).ToShortDateString()
: String.Empty;
QueryExpression queryInvoice = new QueryExpression("invoice");
queryInvoice.ColumnSet = new ColumnSet(new[] { "invoiceid", "gsc_salesinvoicestatus", "gsc_paymentmode", "gsc_downpaymentpercentage",
"gsc_salesexecutiveid", "customerid", "gsc_invoicedate", "gsc_leadsourceid", "gsc_bankid", "gsc_issalesreturned" });
FilterExpression filter = new FilterExpression(LogicalOperator.And);
FilterExpression filter1 = new FilterExpression(LogicalOperator.And);
filter1.Conditions.Add(new ConditionExpression("gsc_branchid", ConditionOperator.Equal, CommonHandler.GetEntityReferenceIdSafe(gvdReport, "gsc_branchid")));
filter1.Conditions.Add(new ConditionExpression("gsc_dealerid", ConditionOperator.Equal, CommonHandler.GetEntityReferenceIdSafe(gvdReport, "gsc_dealerid")));
if (dateFrom != String.Empty)
{
filter1.Conditions.Add(new ConditionExpression("createdon", ConditionOperator.GreaterEqual, dateFrom));
}
if (dateTo != String.Empty)
{
filter1.Conditions.Add(new ConditionExpression("createdon", ConditionOperator.LessEqual, dateTo));
}
FilterExpression filter2 = new FilterExpression(LogicalOperator.Or);
filter2.Conditions.Add(new ConditionExpression("gsc_salesinvoicestatus", ConditionOperator.Equal, 100000002)); //Invoiced
filter2.Conditions.Add(new ConditionExpression("gsc_salesinvoicestatus", ConditionOperator.Equal, 100000003)); //Printed DR
filter2.Conditions.Add(new ConditionExpression("gsc_salesinvoicestatus", ConditionOperator.Equal, 100000004)); //Released
filter2.Conditions.Add(new ConditionExpression("gsc_salesinvoicestatus", ConditionOperator.Equal, 100000005)); //Cancelled
filter.AddFilter(filter1);
filter.AddFilter(filter2);
queryInvoice.Criteria.AddFilter(filter);
EntityCollection invoiceCollection = _organizationService.RetrieveMultiple(queryInvoice);
if (invoiceCollection != null && invoiceCollection.Entities.Count > 0)
{
_tracingService.Trace("Invoice Retrieved..");
foreach (var invoiceEntity in invoiceCollection.Entities)
{
CreateGVDDetails(invoiceEntity, gvdReport);
}
}
_tracingService.Trace("Ended FilterInvoice Method..");
return(null);
}
/// <summary>
/// Users the has role.
/// </summary>
/// <param name="roleCode">The role code.</param>
/// <returns></returns>
public bool HasRole(string roleCode)
{
string userId = this.GetCurrentUserIDString();
if (string.IsNullOrEmpty(userId))
{
return(false);
}
//// TODO: cache roles here
//var list = _UserInRoleService.GetRolesByUserID(userId);
FilterExpression filter = new FilterExpression();
filter.AddFilter(new Filter("UserID", userId));
filter.AddFilter(new Filter("IsActive", true));
var gParams = new GetByFilterParameters(filter, new SortExpression(), 0, 1000, null, GetSourceTypeEnum.View);
var list = GetUserInRoleService().GetByFilter(gParams);
foreach (var item in list)
{
string rCode = FWUtils.EntityUtils.GetObjectFieldValueString(item, "RoleCode");
if (rCode == roleCode)
{
return(true);
}
}
return(false);
}
public void GetFilterStringTest4()
{
FilterExpression target = new FilterExpression();
target.AddFilter(new Filter(vTestCaseTester.ColumnNames.FieldString, "C1"));
target.AddFilter(new Filter(vTestCaseTester.ColumnNames.FieldString, "C2"));
target.LogicalOperator = FilterLogicalOperatorEnum.OR;
FilterExpression filterExp2 = new FilterExpression();
filterExp2.AddFilter(new Filter(vTestCaseTester.ColumnNames.FieldString, "C3"));
filterExp2.AddFilter(new Filter(vTestCaseTester.ColumnNames.FieldString, "C4"));
target.AddFilterExpression(filterExp2);
Assert.AreEqual(target.FiltersList.Count, 3);
List <object> filterValues = new List <object>();
string actual = target.GetFilterString(filterValues);
string expected = "(" + GetSimpleFilterString(vTestCaseTester.ColumnNames.FieldString, "=", Filter.ParameterPrefix + "0") +
" OR " + GetSimpleFilterString(vTestCaseTester.ColumnNames.FieldString, "=", Filter.ParameterPrefix + "1") + "" +
" OR (" + GetSimpleFilterString(vTestCaseTester.ColumnNames.FieldString, "=", Filter.ParameterPrefix + "2") + "" +
" AND " + GetSimpleFilterString(vTestCaseTester.ColumnNames.FieldString, "=", Filter.ParameterPrefix + "3") + ")" +
")";
Assert.AreEqual(expected, actual);
Assert.AreEqual(filterValues.Count, 4);
Assert.AreEqual(filterValues[0], "C1");
Assert.AreEqual(filterValues[1], "C2");
Assert.AreEqual(filterValues[2], "C3");
Assert.AreEqual(filterValues[3], "C4");
}
/// <summary>
/// Gets the pending notification list.
/// </summary>
/// <returns></returns>
public static List <vNotification> GetPendingNotificationList()
{
INotificationService service = (INotificationService)EntityFactory.GetEntityServiceByName(
vNotification.EntityName, "");
FilterExpression filterEmail = new FilterExpression();
filterEmail.AddFilter(new Filter(vNotification.ColumnNames.EmailNotificationStatusID, (int)EntityEnums.NotificationStatusEnum.Pending));
filterEmail.AddFilter(new Filter(vNotification.ColumnNames.IsEmail, true));
filterEmail.AddFilter(new Filter(vNotification.ColumnNames.ReceiverUserEmail, null, FilterOperatorEnum.NotIsNull));
FilterExpression filterSMS = new FilterExpression();
filterSMS.AddFilter(new Filter(vNotification.ColumnNames.SMSNotificationStatusID, (int)EntityEnums.NotificationStatusEnum.Pending));
filterSMS.AddFilter(new Filter(vNotification.ColumnNames.IsSMS, true));
filterSMS.AddFilter(new Filter(vNotification.ColumnNames.ReceiverUserPhoneNumber, null, FilterOperatorEnum.NotIsNull));
FilterExpression filter = new FilterExpression();
filter.AddFilterExpression(filterEmail);
filter.AddFilterExpression(filterSMS);
filter.LogicalOperator = FilterLogicalOperatorEnum.OR;
SortExpression sort = new SortExpression(vNotification.ColumnNames.InsertDate, SortDirectionEnum.ASC);
int numberOfNotifies = 100;
List <vNotification> notificationList = (List <vNotification>)
service.GetByFilter(new GetByFilterParameters(filter, sort, 0, numberOfNotifies, null, GetSourceTypeEnum.View));
return(notificationList);
}
//Please write your properties and functions here. This part will not be replaced.
/// <summary>
/// Gets the unsaved food group.
/// </summary>
/// <param name="p">The paramters</param>
/// <returns></returns>
public FoodGroup GetUnsavedFoodGroup(FoodGroup_GetUnsavedFoodGroupSP p)
{
var filter = new FilterExpression();
filter.AddFilter(vFoodGroup.ColumnNames.UserID, p.UserID);
filter.AddFilter(vFoodGroup.ColumnNames.IsGroupSaved, false);
filter.AddFilter(vFoodGroup.ColumnNames.FoodServingTimeTypeID, p.FoodServingTimeTypeID);
var list = GetByFilterT(new GetByFilterParameters(filter));
if (list.Count > 0)
{
return(list[0]);
}
else
{
var g = new FoodGroup
{
FoodServingTimeTypeID = p.FoodServingTimeTypeID,
IsGroupSaved = false,
UserID = p.UserID,
RecordDateTimeUserLocal = DateTime.Now
};
Insert(g);
return(g);
}
}
public void ExtensionExamples_WhereEqualOr()
{
var qe = new QueryExpression();
qe.Criteria.AddCondition("att3", ConditionOperator.Equal, "value");
var orFilter = new FilterExpression(LogicalOperator.Or);
qe.Criteria.AddFilter(orFilter);
var filter1 = new FilterExpression();
filter1.AddCondition("att1", ConditionOperator.Equal, "Value");
filter1.AddCondition("att2", ConditionOperator.Equal, "Value");
orFilter.AddFilter(filter1);
var filter2 = new FilterExpression();
filter2.AddCondition("att1", ConditionOperator.Equal, "Value1");
filter2.AddCondition("att2", ConditionOperator.Equal, "Value1");
orFilter.AddFilter(filter2);
var qe2 = new QueryExpression();
qe2.WhereEqual("att3", "value");
qe2.WhereEqual(
"att1", "Value",
"att2", "Value",
LogicalOperator.Or,
"att1", "Value1",
"att2", "Value1");
Assert.AreEqual(qe.GetSqlStatement(), qe2.GetSqlStatement());
}
public void SendEmailVerificationTest()
{
long userId = TestEnums.User.constPatientUserID;
TestUtils.Security.SetCurrentUser(userId);
UserService target = CreateNewUserService();
target.SendEmailVerificationLetter(userId);
User user = (User)target.GetByID(userId, new GetByIDParameters());
Assert.IsNotNull(user.EmailVerificationCode, "user.EmailVerificationCode shouldn't be null");
// Checking the notification and log
DateTime afewSecondsAgoDate = DateTime.UtcNow.AddSeconds(-3);
INotificationService notificationService = (INotificationService)
EntityFactory.GetEntityServiceByName(vNotification.EntityName, "");
FilterExpression nFilter = new FilterExpression();
nFilter.AddFilter(new Filter(vNotification.ColumnNames.ReceiverUserID, userId));
nFilter.AddFilter(new Filter(vNotification.ColumnNames.NotificationTemplateID, (int)EntityEnums.NotificationTemplateEnum.EmailVerification));
nFilter.AddFilter(new Filter(vNotification.ColumnNames.InsertDate, afewSecondsAgoDate, FilterOperatorEnum.GreaterThan));
List <Notification> notificationsList = (List <Notification>)notificationService.GetByFilter(new GetByFilterParameters(nFilter));
Assert.AreEqual(1, notificationsList.Count, "notificationsList.Count should be 1. One notification should be sent for emailing to user");
// We don't check log because it depends on the notification service. We don't need it for our unit testing.
//IAppLogService logService = (IAppLogService)
// EntityFactory.GetEntityServiceByName(AppLog.EntityName, "");
//FilterExpression filter = new FilterExpression();
//filter.AddFilter(new Filter())
}
private static void AddWhereInCondition(FilterExpression filterExpression, string columnName, object[] values)
{
if (values.Length == 0)
{
// If no values are in our values array, create a constraint which causing nothing to get returned
var ANDing = new FilterExpression(LogicalOperator.And);
ANDing.AddCondition(columnName, ConditionOperator.Null);
ANDing.AddCondition(columnName, ConditionOperator.NotNull);
filterExpression.AddFilter(ANDing);
}
else if (values.Any(v => v == null))
{
if (values.Any(v => v != null))
{
var ORing = new FilterExpression(LogicalOperator.Or);
ORing.AddCondition(columnName, ConditionOperator.Null);
ORing.AddCondition(columnName, ConditionOperator.In, values.Where(v => values != null));
filterExpression.AddFilter(ORing);
}
else
{
filterExpression.AddCondition(columnName, ConditionOperator.Null);
}
}
else
{
filterExpression.AddCondition(columnName, ConditionOperator.In, values);
}
}
public FilterExpression ToFilterExpression(string searchValue)
{
var filterExpression = new FilterExpression
{
FilterOperator = Operator,
IsQuickFindFilter = isQuickFind
};
foreach (var c in Conditions)
{
filterExpression.AddCondition(c.ToConditionExpression());
}
foreach (var f in Filters)
{
filterExpression.AddFilter(f.ToFilterExpression(searchValue));
}
var searchFilter = GenerateSearchFilter(searchValue);
if (searchFilter != null)
{
filterExpression.AddFilter(searchFilter);
}
return(filterExpression);
}
public void VisitCallPatientTest()
{
long testVisitID = 201;
var visit = VisitEN.GetService().GetByIDV(testVisitID);
TestUtils.Security.SetCurrentUser(TestEnums.User.constDoctorID);
var target = CallLogEN.GetService();
var actual = target.VisitCallPatient(new CallLogVisitCallPatientSP()
{
VisitID = testVisitID
});
Assert.AreEqual(visit.PatientUserID, actual.ReceiverUserID);
Assert.AreEqual(visit.PatientFullName, actual.ReceiverFullName);
DateTime afewSecondsAgoDate = DateTime.UtcNow.AddSeconds(-3);
FilterExpression filter = new FilterExpression();
filter.AddFilter(vCallLog.ColumnNames.AppEntityID, (short)EntityEnums.AppEntityEnum.Visit);
filter.AddFilter(vCallLog.ColumnNames.EntityRecordID, testVisitID);
filter.AddFilter(vCallLog.ColumnNames.StartDate, afewSecondsAgoDate, FilterOperatorEnum.GreaterThan);
filter.AddFilter(vCallLog.ColumnNames.ReceiverUserID, visit.PatientUserID);
Assert.IsTrue(target.GetCount(filter) > 0, "CallLog should be written to CallLog table");
FilterExpression f2 = new FilterExpression();
f2.AddFilter(vMobilePushNotification.ColumnNames.InsertDate, afewSecondsAgoDate, FilterOperatorEnum.GreaterThan);
f2.AddFilter(vMobilePushNotification.ColumnNames.MobilePushTemplateID, (byte)EntityEnums.MobilePushTemplateType.Call_PhoneRing);
Assert.IsTrue(MobilePushNotificationEN.GetService().GetCount(f2) > 0, "MobilePushNotification should be called");
}
//Please write your properties and functions here. This part will not be replaced.
public IList <DailyActivity> GetByTypeAndExternalEntityAndUser(DailyActivity_GetByTypeAndExternalEntityAndUserSP p)
{
var filter = new FilterExpression();
filter.AddFilter(vDailyActivity.ColumnNames.ExternalEntityID, p.ExternalEntityID);
filter.AddFilter(vDailyActivity.ColumnNames.DailyActivityTypeID, p.DailyActivityTypeID);
filter.AddFilter(vDailyActivity.ColumnNames.UserID, p.UserID);
return(GetByFilterT(new GetByFilterParameters(filter)));
}
/// <summary>
/// Adds the column name and value pairs as conditions
/// </summary>
/// <param name="columnNameAndValuePairs">List of pairs that look like this:
/// (string name of the column, value of the column) ie. "name", "John Doe" </param>
///// <param name="logicalName">The logical name of the QueryExpression.EntityName or FilterExpression.EntityName.
///// Used to determine if the Id of the entity is being equal compared to. If so, remove any inactive condition
///// checks</param>
private static FilterExpression WhereEqual(this FilterExpression filterExpression, string entityName,
params object[] columnNameAndValuePairs)
{
int length = columnNameAndValuePairs.Length;
if (length == 0)
{
return(filterExpression);
}
// Get Indexes of all or's and ConditionExpressions
var indexes = Enumerable.Range(0, length);
var ors = indexes.Where(
i => columnNameAndValuePairs.ItemAtIndexIsType(i, typeof(LogicalOperator))).
OrderBy(i => i).ToArray();
var conditions = indexes.Where(
i => columnNameAndValuePairs.ItemAtIndexIsType(i, typeof(ConditionExpression))).
OrderBy(i => i).ToArray();
bool hasOr = ors.Length > 0;
if ((length - ors.Length - conditions.Length) % 2 != 0)
{
throw new ArgumentException("Each Column Name must have a value after it. Invalid " +
"columnNameAndValuePairs length");
}
int orIndex = 0;
int conditionIndex = 0;
FilterExpression orFilter = GetOrFilter(filterExpression, ors);
FilterExpression currentFilter = hasOr ? orFilter.AddFilter(LogicalOperator.And) : filterExpression;
for (int i = 0; i < length; i += 2)
{
if (hasOr && ors.Length > orIndex && ors[orIndex] == i)
{
i++; // Skip LogicalOperator
orIndex++;
currentFilter = orFilter.AddFilter(LogicalOperator.And); // Create new And filter, adding to Or
}
if (conditions.Length > conditionIndex && conditions[conditionIndex] == i)
{
conditionIndex++;
currentFilter.AddCondition(columnNameAndValuePairs[i] as ConditionExpression);
i--; // There is no second parameter, so subtract 1 to look at the next set of pairs
}
else
{
// Non Condition Expression
AddNameValuePairCondition(currentFilter,
(string)columnNameAndValuePairs[i], columnNameAndValuePairs[i + 1], entityName);
}
}
return(filterExpression);
}
static List <int> GetFreeCellNumbers(IOrganizationService service, Guid apcId)
{
var freeCells = new List <int>();
var ordersQuery = new QueryExpression("sb_order")
{
ColumnSet = new ColumnSet("sb_orderid")
};
ordersQuery.Criteria.AddCondition("sb_shipto_apcid", ConditionOperator.Equal, apcId);
ordersQuery.Criteria.AddCondition("sb_orderstatuscode", ConditionOperator.Equal, 110000001);
var orders = service.RetrieveMultiple(ordersQuery).Entities;
var deliveries = new List <Entity>();
foreach (var order in orders)
{
var deliveryQuery = new QueryExpression("sb_delivery")
{
ColumnSet = new ColumnSet("sb_deliverto_apccell")
};
FilterExpression filter = new FilterExpression(LogicalOperator.And);
FilterExpression filter1 = new FilterExpression(LogicalOperator.And);
filter1.Conditions.Add(new ConditionExpression("sb_orderid", ConditionOperator.Equal, order.Id));
filter1.Conditions.Add(new ConditionExpression("sb_deliverto_apccell", ConditionOperator.NotNull));
FilterExpression filter2 = new FilterExpression(LogicalOperator.Or);
filter2.Conditions.Add(new ConditionExpression("sb_deliverystatuscode", ConditionOperator.Equal, 110000003));
filter2.Conditions.Add(new ConditionExpression("sb_deliverystatuscode", ConditionOperator.Equal, 110000004));
filter.AddFilter(filter1);
filter.AddFilter(filter2);
deliveryQuery.Criteria = filter;
deliveries.AddRange(service.RetrieveMultiple(deliveryQuery).Entities);
}
var cellNums = new List <int>();
foreach (var delivery in deliveries)
{
cellNums.Add(delivery.GetAttributeValue <int>("sb_deliverto_apccell"));
}
var apc = service.Retrieve("sb_automatedpostalcenter", apcId, new ColumnSet("sb_freecellscount"));
for (int i = 1; i < apc.GetAttributeValue <int>("sb_freecellscount"); i++)
{
if (cellNums.Contains(i))
{
continue;
}
freeCells.Add(i);
}
return(freeCells);
}
private FilterExpression GetByRangeFilter(DoctorScheduleGetByRangeSP p)
{
FilterExpression filter = new FilterExpression(vDoctorSchedule.ColumnNames.DoctorID, p.DoctorID);
filter.AddFilter(new Filter(vDoctorSchedule.ColumnNames.SlotUnixEpoch, p.StartUnixEpoch, FilterOperatorEnum.GreaterThanOrEqualTo));
filter.AddFilter(new Filter(vDoctorSchedule.ColumnNames.SlotUnixEpoch, p.EndUnixEpoch, FilterOperatorEnum.LessThan));
filter.AddFilter(new Filter(vDoctorSchedule.ColumnNames.IsDisabled, false));
filter.AddFilter(new Filter(vDoctorSchedule.ColumnNames.IsWalkingQueue, false));
return(filter);
}
public List <string> IsDuplicate(IOrganizationService service, string entityName, string conditionValue, Guid businessUnitCondition, List <string> fields, ref string Tracer, Guid leadId)
{
List <string> emailValues = new List <string>();
string toReferName = "false";
QueryExpression qe = new QueryExpression();
qe.EntityName = entityName;
FilterExpression filter = new FilterExpression();
filter.FilterOperator = LogicalOperator.Or;
for (int i = 0; i < fields.Count; i++)
{
filter.Conditions.Add(new ConditionExpression(fields[i], ConditionOperator.Equal, conditionValue));
}
if (entityName == "lead")
{
FilterExpression filter2 = new FilterExpression(LogicalOperator.And);
filter2.AddCondition(new ConditionExpression("leadid", ConditionOperator.NotEqual, leadId));
FilterExpression mainFilter = new FilterExpression(LogicalOperator.And);
mainFilter.AddFilter(filter);
mainFilter.AddFilter(filter2);
qe.Criteria = mainFilter;
}
else
{
qe.Criteria = filter;
}
qe.ColumnSet = new ColumnSet();
qe.ColumnSet = new ColumnSet(true);
qe.AddLink("systemuser", "ownerid", "systemuserid").LinkCriteria.AddCondition("businessunitid", ConditionOperator.Equal, businessUnitCondition);
EntityCollection ec = service.RetrieveMultiple(qe);
if (ec.Entities.Count > 0)
{
var name = ec.Entities[0].Attributes["fullname"].ToString();
toReferName = ((EntityReference)ec.Entities[0].Attributes["ownerid"]).Name;
existingLeadName = ec.Entities[0].Attributes["fullname"].ToString();
existingLeadOwner = ((EntityReference)ec.Entities[0].Attributes["ownerid"]).Name.ToString();
Guid existingLeadOwnerId = ((EntityReference)ec.Entities[0].Attributes["ownerid"]).Id;
emailValues.Add(toReferName);
emailValues.Add(existingLeadName);
emailValues.Add(existingLeadOwner);
emailValues.Add(existingLeadOwnerId.ToString());
emailValues.Add(context.InitiatingUserId.ToString());
return(emailValues);
}
return(emailValues);
}
//Please write your properties and functions here. This part will not be replaced.
/// <summary>
/// returns roles of a specific user
/// </summary>
/// <param name="userId">user identifier</param>
/// <returns></returns>
public IList <vUserInRole> GetRolesByUserID(string userId)
{
FilterExpression filter = new FilterExpression();
filter.AddFilter(new Filter(vUserInRole.ColumnNames.UserID, userId));
filter.AddFilter(new Filter(vUserInRole.ColumnNames.IsActive, true));
var gParams = new GetByFilterParameters(filter, new SortExpression());
var list = GetByFilterV(gParams);
return(list);
}
public ViewNeedClass CheckNeed(long doctorId)
{
var filter = new FilterExpression(vDoctorSchedule.ColumnNames.DoctorID, doctorId);
filter.AddFilter(vDoctorSchedule.ColumnNames.SlotUnixEpoch, DateTimeEpoch.GetUtcNowEpoch(), FilterOperatorEnum.GreaterThan);
filter.AddFilter(vDoctorSchedule.ColumnNames.NumberOfFreePositions, 0, FilterOperatorEnum.GreaterThan);
if (DoctorScheduleEN.GetService().GetCount(filter) < 1)
{
return(new ViewNeedClass("No available time is available for booking.", "DoctorSchedule-CalendarEdit"));
}
return(null);
}
private void AssertNotificationExists(long receiverUserID, EntityEnums.NotificationTemplateEnum template)
{
DateTime afewSecondsAgoDate = DateTime.UtcNow.AddSeconds(-30);
INotificationService notificationService = NotificationEN.GetService();
FilterExpression nFilter = new FilterExpression();
nFilter.AddFilter(new Filter(vNotification.ColumnNames.ReceiverUserID, receiverUserID));
nFilter.AddFilter(new Filter(vNotification.ColumnNames.NotificationTemplateID, (int)template));
nFilter.AddFilter(new Filter(vNotification.ColumnNames.InsertDate, afewSecondsAgoDate, FilterOperatorEnum.GreaterThan));
List <Notification> notificationsList = (List <Notification>)notificationService.GetByFilter(new GetByFilterParameters(nFilter));
Assert.IsTrue(notificationsList.Count > 0, "notificationsList.Count should be 1. One notification should be sent for emailing to user");
}
//Please write your properties and functions here. This part will not be replaced.
/// <summary>
/// Adds a token to the database
/// </summary>
/// <param name="token">token</param>
public void AddToken(WebApiToken token)
{
FilterExpression filter = new FilterExpression();
filter.AddFilter(vWebApiToken.ColumnNames.UserID, token.UserID);
filter.AddFilter(vWebApiToken.ColumnNames.WebApiClientID, token.WebApiClientID);
var list = GetByFilterT(new GetByFilterParameters(filter));
foreach (var item in list)
{
Delete(item);
}
Insert(token);
}
/// <summary>
/// Gets the visits by date.
/// </summary>
/// <param name="doctorId">doctor identifier</param>
/// <param name="selectedDate">The selected date.</param>
/// <returns></returns>
public List <vVisit> GetDoctorVisitsByDate(long doctorId, DateTime selectedDate)
{
DateTime startDate = new DateTime(selectedDate.Year, selectedDate.Month, selectedDate.Day);
DateTime endDate = startDate.AddDays(1);
FilterExpression filter = new FilterExpression();
filter.AddFilter(new Filter(vVisit.ColumnNames.SlotUnixEpoch, DateTimeEpoch.ConvertDateToSecondsEpoch(startDate), FilterOperatorEnum.GreaterThanOrEqualTo));
filter.AddFilter(new Filter(vVisit.ColumnNames.SlotUnixEpoch, DateTimeEpoch.ConvertDateToSecondsEpoch(endDate), FilterOperatorEnum.LessThan));
filter.AddFilter(new Filter(vVisit.ColumnNames.DoctorID, doctorId));
SortExpression sort = new SortExpression(vVisit.ColumnNames.SlotUnixEpoch);
return((List <vVisit>)GetByFilter(new GetByFilterParameters(filter, sort, 0, 1000, null, GetSourceTypeEnum.View)));
}
//Please write your properties and functions here. This part will not be replaced.
/// <summary>
/// Gets list of doctors by its phone number
/// </summary>
/// <param name="phoneNumber"></param>
/// <returns></returns>
public IList <vDoctor> SearchByClinicPhoneNumber(DoctorSearchByClinicPhoneNumberSP p)
{
string searchablePhoneNumber = UTD.Tricorder.Common.PhoneNumberUtils.MakeSearchablePhoneNumber(p.PhoneNumber);
if (string.IsNullOrEmpty(searchablePhoneNumber) == false)
{
FilterExpression filter = new FilterExpression();
filter.AddFilter(vDoctor.ColumnNames.ClinicPhoneNumberSearchable, searchablePhoneNumber, FilterOperatorEnum.Contains);
SortExpression sort = new SortExpression(vDoctor.ColumnNames.LastName);
List <string> columns = new List <string>();
columns.Add(vDoctor.ColumnNames.NamePrefix);
columns.Add(vDoctor.ColumnNames.FirstName);
columns.Add(vDoctor.ColumnNames.LastName);
columns.Add(vDoctor.ColumnNames.ClinicPhoneNumber);
columns.Add(vDoctor.ColumnNames.ClinicAddress);
columns.Add(vDoctor.ColumnNames.DoctorID);
return(GetByFilterV(new GetByFilterParameters(filter, sort, 0, 10, columns, GetSourceTypeEnum.View)));
}
else
{
return(new List <vDoctor>());
}
}
public static FilterExpression ToFilterExpression(this XElement elem, XrmFakedContext ctx)
{
var filterExpression = new FilterExpression();
filterExpression.FilterOperator = elem.GetAttribute("type").Value.Equals("and") ?
LogicalOperator.And : LogicalOperator.Or;
//Process other filters recursively
var otherFilters = elem
.Elements() //child nodes of this filter
.Where(el => el.Name.LocalName.Equals("filter"))
.Select(el => el.ToFilterExpression(ctx))
.ToList();
//Process conditions
var conditions = elem
.Elements() //child nodes of this filter
.Where(el => el.Name.LocalName.Equals("condition"))
.Select(el => el.ToConditionExpression(ctx))
.ToList();
foreach (var c in conditions)
{
filterExpression.AddCondition(c);
}
foreach (var f in otherFilters)
{
filterExpression.AddFilter(f);
}
return(filterExpression);
}
public void RegisterQuickTest()
{
UserService target = CreateNewUserService();
UserRegisterQuickFromDoctorSP p = new UserRegisterQuickFromDoctorSP();
p.FirstName = TestUtils.RandomUtils.RandomString(100);
p.LastName = TestUtils.RandomUtils.RandomString(100);
p.PhoneNumber = TestUtils.RandomUtils.RandomPhoneNumber();
p.ReferrerUserID = (long)TestEnums.User.constDoctorID;
User insertedUser = (User)target.RegisterQuickFromDoctor(p);
string phoneNumberSearchable = PhoneNumberUtils.MakeSearchablePhoneNumber(p.PhoneNumber);
User u = (User)target.GetByUserNameT(insertedUser.UserName);
Assert.AreEqual(insertedUser.UserName.ToLower(), u.UserName, "User name didn't inserted correctly");
//Assert.AreEqual(phoneNumberSearchable, u.PhoneNumberSearchable, "phoneNumber didn't inserted correctly");
UserInRoleService uInRoleService = (UserInRoleService)EntityFactory.GetEntityServiceByName(vUserInRole.EntityName, "");
var count = uInRoleService.GetCount(new FilterExpression(new Filter(vUserInRole.ColumnNames.UserID, u.UserID)));
Assert.AreEqual(1, count, "we expect that user be in one of the assigned roles"); // we expect that user be in one of the assigned roles
IDoctor_PatientService doctor_PatientService = Doctor_PatientEN.GetService();
FilterExpression filter = new FilterExpression(vDoctor_Patient.ColumnNames.DoctorID, p.ReferrerUserID);
filter.AddFilter(vDoctor_Patient.ColumnNames.PatientUserID, u.UserID);
Assert.AreEqual(1, doctor_PatientService.GetCount(filter), "Doctor_Patient is not exists.");
}
/// <summary>
/// Checks if a doctor available in a certain time
/// </summary>
/// <param name="p">parameters</param>
/// <returns></returns>
public bool IsTimeAvailable(DoctorScheduleIsTimeAvailableSP p)
{
FilterExpression filter = new FilterExpression(vDoctorSchedule.ColumnNames.DoctorID, p.DoctorID);
filter.AddFilter(vDoctorSchedule.ColumnNames.SlotUnixEpoch, p.SelectedDateTimeUnixEpoch);
return(this.GetCount(filter) > 0);
}
/// <summary>
/// Gets the maximum end offset.
/// </summary>
/// <param name="timeSeriesTypeID">The time series type identifier.</param>
/// <param name="userID">The user identifier.</param>
/// <returns></returns>
private int GetMaxEndOffset(byte timeSeriesTypeID, long userID)
{
// NOTE: Service can not be used because no user credential is available here
//ITimeSeriesStripService service = (ITimeSeriesStripService)
// EntityFactory.GetEntityServiceByName(TimeSeriesStrip.EntityName, "");
TimeSeriesStripDA service = (TimeSeriesStripDA)
EntityFactory.GetEntityDataAccessByName(vTimeSeriesStrip.EntityName, "");
FilterExpression filter = new FilterExpression();
filter.AddFilter(new Filter(vTimeSeriesStrip.ColumnNames.UserID, userID));
filter.AddFilter(new Filter(vTimeSeriesStrip.ColumnNames.TimeSeriesTypeID, timeSeriesTypeID));
return(Convert.ToInt32(service.GetMax(vTimeSeriesStrip.ColumnNames.EndDateOffset, filter)));
}
/// <summary>
/// Helper function to get the or filter based on the filterexpression. If it already is or, just return it.
/// Else, return a new child or filter
/// </summary>
/// <param name="filterExpression"></param>
/// <param name="ors"></param>
/// <returns></returns>
private static FilterExpression GetOrFilter(FilterExpression filterExpression, int[] ors)
{
FilterExpression orFilter = null;
if (ors.Length > 0)
{
if (ors[0] == 0)
{
throw new ArgumentException("WhereEqual statement can not start with LogicalOperator value");
}
for (int i = 0; i < ors.Length - 1; i++)
{
// Check to ensure the index of the current plus 1 doesn't equal the index of the next
if (ors[i] + 1 == ors[i + 1])
{
throw new ArgumentException("All LogicalOperator values must have at least one column value seperating them");
}
}
if (filterExpression.FilterOperator == LogicalOperator.Or)
{
orFilter = filterExpression;
}
else
{
orFilter = new FilterExpression(LogicalOperator.Or);
filterExpression.AddFilter(orFilter);
}
}
return(orFilter);
}
public void GetFilterStringTest2()
{
FilterExpression target = new FilterExpression();
target.AddFilter(new Filter(vTestCaseTester.ColumnNames.FieldString, "C0"));
target.AddFilter(new Filter(vTestCaseTester.ColumnNames.FieldString, "C1"));
List <object> filterValues = new List <object>();
string actual = target.GetFilterString(filterValues);
string expected = "(" + GetSimpleFilterString(vTestCaseTester.ColumnNames.FieldString, "=", Filter.ParameterPrefix + "0") + " " + "AND" +
" " + GetSimpleFilterString(vTestCaseTester.ColumnNames.FieldString, "=", Filter.ParameterPrefix + "1") + ")";
Assert.AreEqual(expected, actual);
Assert.AreEqual(filterValues.Count, 2);
Assert.AreEqual(filterValues[0], "C0");
Assert.AreEqual(filterValues[1], "C1");
}
public void CreatePaymentForVisitTest()
{
PaymentService target = CreateNewPaymentService();
Visit visit = InsertVisit(EntityEnums.VisitStatusEnum.EndSuccess, EntityEnums.PaymentStatusEnum.NotStarted);
PaymentCreatePaymentForVisitSP p = new PaymentCreatePaymentForVisitSP();
p.VisitID = visit.VisitID;
p.Amount = 100;
p.ServiceChargeAmount = 1;
target.CreatePaymentForVisit(p);
// Making sure that record saved in the database
var filter = new FilterExpression(new Filter(vPayment.ColumnNames.AppEntityRecordIDValue, visit.VisitID));
filter.AddFilter(new Filter(vPayment.ColumnNames.AppEntityID, (int)EntityEnums.PaymentEntityEnum.Visit));
var list = target.GetByFilter(new GetByFilterParameters(filter, new SortExpression(), 0, 1, null, GetSourceTypeEnum.View));
DeleteVisit(visit.VisitID);
Assert.AreEqual(list.Count, 1);
foreach (vPayment payment in list)
{
Assert.AreEqual(payment.PaymentStatusID, (int)EntityEnums.PaymentStatusEnum.PendingWithoutPayKey);
}
}
private QueryExpression GenerateEnhancedQuery(QueryExpression sourceQuery, FilterExpression linkedEntityFilter, bool addLinkedFilterToQuickFind)
{
var processName = $"{nameof(QuickFindQueryBuilder<TEntity>)}.{nameof(GenerateEnhancedQuery)}";
executionContext.Trace($"Entered {processName}");
if (linkedEntityFilter is null || linkedEntityFilter.Conditions.Count <= 0)
{
executionContext.Trace($"Exiting {processName} - Linked Entity Filter does not contain any conditions, Returning source query.");
return(sourceQuery);
}
var replacementQuery = new QueryExpression()
{
EntityName = sourceQuery.EntityName,
ColumnSet = sourceQuery.ColumnSet,
Distinct = true
};
// copy all existing linked entities from the source query
foreach (var linkedEntity in sourceQuery.LinkEntities)
{
replacementQuery.LinkEntities.Add(linkedEntity);
}
// copy all existing sort orders from the source query
foreach (var columnOrder in sourceQueryExpresion.Orders)
{
replacementQuery.AddOrder(columnOrder.AttributeName, columnOrder.OrderType);
}
if (addLinkedFilterToQuickFind)
{
// Search within results limited by existing filter criteria - add linked entity filter
// to the "Quick Find Or Filter"
replacementQuery.Criteria = sourceQueryExpresion.Criteria;
FilterExpression quickFindFilter = null;
if (Helpers.TryGetQuickFindFilter(replacementQuery.Criteria, out quickFindFilter))
{
quickFindFilter.AddFilter(linkedEntityFilter);
}
}
else
{
// Full entity search - set replacement query to existing criteria OR linked entity filter
replacementQuery.Criteria = new FilterExpression(LogicalOperator.Or);
replacementQuery.Criteria.AddFilter(sourceQueryExpresion.Criteria);
replacementQuery.Criteria.AddFilter(linkedEntityFilter);
}
// Remove any quickfind flags in the filter to avoid blocks based
// on setting of Organization.QuickFindRecordLimitEnabled flag. See
// https://msdn.microsoft.com/en-us/library/gg328300.aspx
Helpers.ClearQuickFindFlags(replacementQuery.Criteria);
executionContext.Trace($"Exiting {processName} - Completed.");
return(replacementQuery);
}
/// <summary>
/// Amazons the upload request information of for Amazon S3
/// </summary>
/// <param name="p">parameters</param>
/// <returns></returns>
public AppFileAmazonS3DirectHttpUploadData AmazonUploadRequest(AppFileAmazonUploadRequestSP p)
{
Check.Require(string.IsNullOrEmpty(p.FileName) == false);
Check.Require(p.AppFileTypeID > 0);
Check.Require(p.AppEntityRecordIDValue > 0);
var biz = (AppFileBR)BusinessLogicObject;
biz.AmazonUploadRequestPre(p);
vAppFile appFile = null;
AppFileType fileType = (AppFileType)AppFileTypeEN.GetService().GetByID(p.AppFileTypeID, new GetByIDParameters());
// checking business rules at first
biz.AmazonUploadRequest(fileType, p);
if (fileType.HasSecurityCheck == true)
{
CheckUploadRequestSecurity((EntityEnums.AppEntityFileTypeEnum)fileType.AppFileTypeID, p);
}
if (fileType.MaxNumberOfFiles == 1) // single file upload
{
FilterExpression filter = new FilterExpression();
filter.AddFilter(vAppFile.ColumnNames.AppFileTypeID, p.AppFileTypeID);
filter.AddFilter(vAppFile.ColumnNames.AppEntityRecordIDValue, p.AppEntityRecordIDValue);
IList <vAppFile> list = GetByFilterV(new GetByFilterParameters(filter));
if (list.Count == 0) // create a record
{
appFile = InsertNewFile(p.FileName, p.AppFileTypeID, p.AppEntityRecordIDValue);
}
else
{
appFile = list[0];
}
}
else // multiple file upload
{
appFile = InsertNewFile(p.FileName, p.AppFileTypeID, p.AppEntityRecordIDValue);
}
long userId = FWUtils.SecurityUtils.GetCurrentUserIDLong();
var result = GetAmazonUploadData(fileType, appFile);
return(result);
}
public static FilterExpression ToFilterExpression(this XElement elem, XrmFakedContext ctx)
{
var filterExpression = new FilterExpression();
filterExpression.FilterOperator = elem.GetAttribute("type").Value.Equals("and") ?
LogicalOperator.And : LogicalOperator.Or;
//Process other filters recursively
var otherFilters = elem
.Elements() //child nodes of this filter
.Where(el => el.Name.LocalName.Equals("filter"))
.Select(el => el.ToFilterExpression(ctx))
.ToList();
//Process conditions
var conditions = elem
.Elements() //child nodes of this filter
.Where(el => el.Name.LocalName.Equals("condition"))
.Select(el => el.ToConditionExpression(ctx))
.ToList();
foreach (var c in conditions)
filterExpression.AddCondition(c);
foreach (var f in otherFilters)
filterExpression.AddFilter(f);
return filterExpression;
}
public void Experiment_For_Filter_Groups()
{
// var sql = string.Format("Select C.firstname, C.lastname From contact Where firstname Like '%ax%' ");
var connectionString = ConfigurationManager.ConnectionStrings["CrmOrganisation"];
var serviceProvider = new CrmServiceProvider(new ExplicitConnectionStringProviderWithFallbackToConfig() { OrganisationServiceConnectionString = connectionString.ConnectionString },
new CrmClientCredentialsProvider());
var orgService = serviceProvider.GetOrganisationService();
using (orgService as IDisposable)
{
// var request = new RetrieveMultipleRequest();
var query = new QueryExpression("contact");
// request.Query = query;
query.ColumnSet.AddColumn("firstname");
query.ColumnSet.AddColumn("lastname");
var condition1 = new ConditionExpression("firstname", ConditionOperator.Equal, "Max");
var condition2 = new ConditionExpression("lastname", ConditionOperator.Equal, "Planck");
var filter1 = new FilterExpression(LogicalOperator.And);
filter1.AddCondition(condition1);
filter1.AddCondition(condition2);
var condition3 = new ConditionExpression("firstname", ConditionOperator.Equal, "Albert");
var filter2 = new FilterExpression(LogicalOperator.Or);
filter2.AddCondition(condition3);
filter2.AddFilter(filter1);
query.Criteria.Filters.Clear();
query.Criteria.AddFilter(filter2);
var results = orgService.RetrieveMultiple(query);
int resultCount = 0;
foreach (var r in results.Entities)
{
resultCount++;
Console.WriteLine(string.Format("{0} {1}", (string)r["firstname"], (string)r["lastname"]));
}
Console.WriteLine("There were " + resultCount + " results..");
}
}
