public static IConventionDbFunction AddDbFunction(
[NotNull] this IConventionModel model,
[NotNull] MethodInfo methodInfo,
bool fromDataAnnotation = false)
=> DbFunction.AddDbFunction(
(IMutableModel)model, Check.NotNull(methodInfo, nameof(methodInfo)),
fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
public static void SendIncidentReport(string startTime, string endTime, double TimeZone, string SendTo)
{
double cutTimeZone = 0 - TimeZone;
var StartDateTime = Convert.ToDateTime(startTime).AddHours(cutTimeZone);
var EndDateTime = Convert.ToDateTime(endTime).AddHours(cutTimeZone);
startTime = StartDateTime.ToString("yyyy-MM-dd HH:mm");
endTime = EndDateTime.ToString("yyyy-MM-dd HH:mm");
string TemplatePath = EmailExtend.MapPath("/Views/Home/IncidentReportTemplate.cshtml");
var index = File.ReadAllText(TemplatePath, System.Text.Encoding.GetEncoding("GBK"));
var ModelList = DbFunction.IncidentHistoryEmail(startTime, endTime, TimeZone);
var OpenCount = ModelList.Count(x => x.GuestMood == "--");
var SatisfiedCount = ModelList.Count(x => x.GuestMood == "Staisfied");
var AcceptedCount = ModelList.Count(x => x.GuestMood == "Accepted");
var AngryCount = ModelList.Count(x => x.GuestMood == "Angry");
var ComplaintCount = ModelList.Count(x => x.GuestMood == "Complaint");
var ImpatientCount = ModelList.Count(x => x.GuestMood == "Impatient");
var result = Razor.Parse(index, new
{
OpenCount = ModelList.Count(x => x.GuestMood == "--"),
SatisfiedCount = ModelList.Count(x => x.GuestMood == "Staisfied"),
AcceptedCount = ModelList.Count(x => x.GuestMood == "Accepted"),
AngryCount = ModelList.Count(x => x.GuestMood == "Angry"),
ComplaintCount = ModelList.Count(x => x.GuestMood == "Complaint"),
ImpatientCount = ModelList.Count(x => x.GuestMood == "Impatient"),
ModelList
});
EmailExtend.SendEmail(SendTo, string.Format("Incident Report {0} to {1}", StartDateTime.ToString("MM/dd/yyyy"), EndDateTime.ToString("MM/dd/yyyy")), result);
}
/// <summary>
/// Removes the <see cref="IMutableDbFunction" /> that is mapped to the method represented by the given
/// <see cref="MethodInfo" />.
/// </summary>
/// <param name="model"> The model to find the function in. </param>
/// <param name="method"> The <see cref="MethodInfo" /> for the method that is mapped to the function. </param>
/// <returns> The removed <see cref="IMutableDbFunction" /> or <c>null</c> if the method is not mapped. </returns>
public static IMutableDbFunction RemoveDbFunction([NotNull] this IMutableModel model, [NotNull] MethodInfo method)
{
Check.NotNull(model, nameof(model));
Check.NotNull(method, nameof(method));
return(DbFunction.RemoveDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(method, nameof(method))));
}
public string getDBType(string PID)
{
ExcelDataBase.Database db = DbFunction.GetDB("");
return(db.DBType.Equals(DataBaseType.ORA) ? "ORA" : "MSS");
//GS_PublicVar.Dev_LoginGS(PID);
//return Convert.ToString(CommonFunction.GlobalVariable["Genersoft.BS.Public.DbType"]).Trim();
}
/// <summary>
/// Finds a <see cref="IDbFunction" /> that is mapped to the method represented by the given <see cref="MethodInfo" />.
/// </summary>
/// <param name="model"> The model to find the function in. </param>
/// <param name="method"> The <see cref="MethodInfo" /> for the method that is mapped to the function. </param>
/// <returns> The <see cref="IDbFunction" /> or <c>null</c> if the method is not mapped. </returns>
public static IDbFunction FindDbFunction([NotNull] this IModel model, [NotNull] MethodInfo method)
{
Check.NotNull(model, nameof(model));
Check.NotNull(method, nameof(method));
return(DbFunction.FindDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(method, nameof(method))));
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public DbFunctionParameter(
DbFunction function,
string name,
Type clrType)
{
Name = name;
Function = function;
ClrType = clrType;
_builder = new InternalDbFunctionParameterBuilder(this, function.Builder.ModelBuilder);
}
public static IConventionDbFunction AddDbFunction(
[NotNull] this IConventionModel model,
[NotNull] string name,
[NotNull] Type returnType,
bool fromDataAnnotation = false)
=> DbFunction.AddDbFunction(
(IMutableModel)model,
Check.NotNull(name, nameof(name)),
returnType,
fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
//public ActionResult About()
//{
// ViewBag.Message = "Your application description page.";
// return View();
//}
//public ActionResult Contact()
//{
// ViewBag.Message = "Your contact page.";
// return View();
//}
public JsonResult GetUserByParentID(int ParentID)
{
List <UserInfo> UserInfoList = new List <UserInfo>();
if (ParentID != 0)
{
UserInfoList = DbFunction.GetUserList(ParentID);
}
return(Json(UserInfoList));
}
public JsonResult GetMetricByParentID(int ParentID)
{
List <TaskMetric> MetricList = new List <TaskMetric>();
if (ParentID != 0)
{
MetricList = DbFunction.GetMetricList(ParentID);
}
return(Json(MetricList));
}
public JsonResult GetLocationByParentID(string ParentID)
{
List <ZoneInfo> locationList = new List <ZoneInfo>();
if (ParentID != "")
{
locationList = DbFunction.GetLocationList(ParentID);
}
return(Json(locationList));
}
public DataSet getDataSet(string processID, string sql)
{
string tmp = "";
try
{
sql = DecSql(sql);
return(DbFunction.ExecuteDataSet(sql));
}
catch (Exception ex)
{
throw new Exception(sql + tmp + " <br> " + ex.Message);
}
}
public QueryResult Execute(string query, MongoUrl url, string database)
{
if (String.IsNullOrWhiteSpace(query))
{
return(null);
}
query = query.Trim();
Module module = ModuleFactory.GetModule(query);
DbFunction function = module.GetDbFunction(query);
function.Url = url;
function.DatabaseName = database;
function.Url = url;
var result = function.Execute();
return(result);
}
public override DbFunction GetDbFunction(string query)
{
DbFunction dbFunction = null;
if (Regex.IsMatch(query, Patterns.find))
{
dbFunction = new Find(query);
}
else if (Regex.IsMatch(query, Patterns.findOne))
{
dbFunction = new FindOne(query);
}
else if (Regex.IsMatch(query, Patterns.findAndModify))
{
dbFunction = new FindAndModify(query);
}
return(dbFunction);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
//modelBuilder.Entity<Person>().ToTable("People");
//modelBuilder.Entity<BankAccount>().ToTable("People");
//modelBuilder.Entity<Person>().HasOne(c => c.BankAccount).WithOne(c => c.Person)
// .HasForeignKey<Person>(c => c.Id);
//modelBuilder.Entity<Person>().OwnsOne(c => c.Home);
modelBuilder.Entity <Person>().HasDiscriminator <int>("Split").HasValue <Person>(1)
.HasValue <Teacher>(2);
modelBuilder.HasDbFunction(() => DbFunction.MyFunction());
modelBuilder.Entity <Person>().Property(c => c.Year)
.HasComputedColumnSql("DatePart(yyyy,[BirthDate])");
modelBuilder.Entity <Person>().Property(c => c.BirthDate).HasValueGenerator <DateTimeValueGenerator>();
//modelBuilder.Entity<Person>().Property(c => c.BirthDate).HasDefaultValueSql("getdate()");
//modelBuilder.HasSequence<int>("TestInt", c => {
// c.HasMin(12);
// c.IncrementsBy(2);
//});
//modelBuilder.Entity<Person>().Property(c => c.FirstName)
// .IsConcurrencyToken();
modelBuilder.Entity <Person>().Property(c => c.Token).IsRowVersion();
//modelBuilder.Entity<BankAccount>().Property(c => c.RowVersion).IsRowVersion();
modelBuilder.Entity <Person>().HasData(
new Person {
BirthDate = DateTime.Now,
FirstName = "1",
LastName = "2",
Id = 1
}
);
}
public static IMutableDbFunction AddDbFunction(
[NotNull] this IMutableModel model,
[NotNull] string name,
[NotNull] Type returnType)
=> DbFunction.AddDbFunction(
model, Check.NotNull(name, nameof(name)), returnType, ConfigurationSource.Explicit);
public static IMutableDbFunction AddDbFunction([NotNull] this IMutableModel model, [NotNull] MethodInfo methodInfo)
=> DbFunction.AddDbFunction(
model, Check.NotNull(methodInfo, nameof(methodInfo)), ConfigurationSource.Explicit) !;
public static IDbFunction?FindDbFunction([NotNull] this IModel model, [NotNull] string name)
=> DbFunction.FindDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(name, nameof(name)));
/// <summary> /// Returns all functions contained in the model. /// </summary> /// <param name="model"> The model to get the functions in. </param> public static IEnumerable <IDbFunction> GetDbFunctions(this IReadOnlyModel model) => DbFunction.GetDbFunctions((Model)Check.NotNull(model, nameof(model)));
/// <summary> /// Returns all functions contained in the model. /// </summary> /// <param name="model"> The model to get the functions in. </param> public static IEnumerable <IMutableDbFunction> GetDbFunctions(this IMutableModel model) => DbFunction.GetDbFunctions((Model)Check.NotNull(model, nameof(model))).Cast <IMutableDbFunction>();
/// <summary>
/// Removes the function that is mapped to the method represented by the given
/// <see cref="MethodInfo" />.
/// </summary>
/// <param name="model"> The model to find the function in. </param>
/// <param name="method"> The <see cref="MethodInfo" /> for the method that is mapped to the function. </param>
/// <returns> The removed function or <see langword="null" /> if the method is not mapped. </returns>
public static IMutableDbFunction?RemoveDbFunction(this IMutableModel model, MethodInfo method)
=> DbFunction.RemoveDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(method, nameof(method)));
/// <summary>
/// Finds a function that is mapped to the method represented by the given name.
/// </summary>
/// <param name="model"> The model to find the function in. </param>
/// <param name="name"> The model name of the function. </param>
/// <returns> The function or <see langword="null" /> if the method is not mapped. </returns>
public static IReadOnlyDbFunction?FindDbFunction(this IReadOnlyModel model, string name)
=> DbFunction.FindDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(name, nameof(name)));
partial void OnModelCreatingPartial(ModelBuilder modelBuilder)
{
modelBuilder.HasDbFunction(() => DbFunction.ExampleFunction(default(string)));
}
public static IEnumerable <IConventionDbFunction> GetDbFunctions([NotNull] this IConventionModel model) => DbFunction.GetDbFunctions((Model)Check.NotNull(model, nameof(model)));
public static IMutableDbFunction?RemoveDbFunction([NotNull] this IMutableModel model, [NotNull] string name)
=> DbFunction.RemoveDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(name, nameof(name)));
public static IEnumerable <IDbFunction> GetDbFunctions([NotNull] this IModel model) => DbFunction.GetDbFunctions(Check.NotNull(model, nameof(model)));
public JsonResult GetTaskFrequencyDistributionDetails(string startTime, string endTime, string DepartmentName, string TimeHour)
{
List <SearchInfo> ModelList = DbFunction.GetTaskFrequencyDistributionDetails(DepartmentName, startTime, endTime, TimeHour);
return(Json(ModelList));
}
internal dynamic findOne(DbFunction dbFunction)
{
ConnectionManager.OpenConnection(dbFunction.Url, dbFunction.DatabaseName);
var collection = ConnectionManager.GetCollection(dbFunction.Collection);
BsonDocument filter = new BsonDocument();
BsonDocument projection = new BsonDocument();
if (dbFunction.Arguments.Count > 0
&& !dbFunction.Arguments[0].GetType().Name.Equals(DataType.BsonDocument))
{
HasError = true;
return FindErrors.GetDontKnowHowToMessageObject();
}
if (dbFunction.SuffixFunction != null)
{
HasError = true;
return FindErrors.NotAFunction(dbFunction);
}
switch (dbFunction.Arguments.Count)
{
case 0:
{
return collection.Find(filter).FirstOrDefault();
}
case 1:
{
filter = dbFunction.Arguments[0].ToBsonDocument();
return collection.Find(filter).FirstOrDefault();
}
case 2:
{
if (dbFunction.Arguments[1].GetType().Name.Equals(DataType.BsonDocument))
{
filter = dbFunction.Arguments[0].ToBsonDocument();
projection = dbFunction.Arguments[1].ToBsonDocument();
}
return collection.Find(filter).Limit(1).Project(projection).FirstOrDefault();
}
default:
{
if (dbFunction.Arguments[3] is BsonString)
{
if (dbFunction.Arguments[1].GetType().Name.Equals(DataType.BsonDocument))
{
filter = dbFunction.Arguments[0].ToBsonDocument();
projection = dbFunction.Arguments[1].ToBsonDocument();
}
int limit = dbFunction.Arguments[2].ToInt32();
return collection.Find(filter).Limit(1).Project(projection).Limit(limit).FirstOrDefault();
}
HasError = true;
return FindErrors.GetArgumentDataTypeMissMatch();
}
}
}
public DbFunctionBuilder([NotNull] DbFunction function)
{
Check.NotNull(function, nameof(function));
_builder = new InternalDbFunctionBuilder(function);
}
public DbFunctionBuilder([NotNull] IMutableDbFunction function)
{
Check.NotNull(function, nameof(function));
_function = (DbFunction)function;
}
/// <summary>
/// Finds a function that is mapped to the method represented by the given <see cref="MethodInfo" />.
/// </summary>
/// <param name="model"> The model to find the function in. </param>
/// <param name="method"> The <see cref="MethodInfo" /> for the method that is mapped to the function. </param>
/// <returns> The function or <see langword="null" /> if the method is not mapped. </returns>
public static IReadOnlyDbFunction?FindDbFunction(this IReadOnlyModel model, MethodInfo method)
=> DbFunction.FindDbFunction(
Check.NotNull(model, nameof(model)),
Check.NotNull(method, nameof(method)));
