protected override void GenerateFrom(ModelDetail modelDetail, ref CharWriteBuffer sb)
{
sb.Write("FROM`");
sb.Write(modelDetail.DataSourceEntityName);
sb.Write('`');
AppendLineBreak(ref sb);
}
protected override void GenerateSelect(QueryOperation select, Graph graph, ModelDetail modelDetail, ref CharWriteBuffer sb)
{
switch (select)
{
case QueryOperation.Many:
sb.Write("SELECT");
GenerateSelectProperties(graph, modelDetail, ref sb);
break;
case QueryOperation.First:
sb.Write("SELECT");
GenerateSelectProperties(graph, modelDetail, ref sb);
break;
case QueryOperation.Single:
sb.Write("SELECT");
GenerateSelectProperties(graph, modelDetail, ref sb);
break;
case QueryOperation.Count:
sb.Write("SELECT COUNT(1)");
AppendLineBreak(ref sb);
break;
case QueryOperation.Any:
sb.Write("SELECT 1");
AppendLineBreak(ref sb);
break;
}
}
//this will add the entered data to modelDetails table
private void btnAddNew_Click(object sender, EventArgs e)
{
ModelDetail NewRecord = new ModelDetail();
NewRecord.ModelID = (int)cbModel.SelectedValue;
NewRecord.Engine = txtEngine.Text;
int.TryParse(cbYear.SelectedItem.ToString(), out int year);
NewRecord.Year = year;
Enum.TryParse <StatusEnum>(cbStatus.SelectedValue.ToString(), out StatusEnum statusEnum);
NewRecord.Status = statusEnum;
Enum.TryParse <FuelTypeEnum>(cbFuel.SelectedValue.ToString(), out FuelTypeEnum fuelTypeEnum);
NewRecord.FuelType = fuelTypeEnum;
Enum.TryParse <ColourEnum>(cbColour.SelectedValue.ToString(), out ColourEnum colourEnum);
NewRecord.Colour = colourEnum;
Enum.TryParse <BodyTypeEnum>(cbBody.SelectedValue.ToString(), out BodyTypeEnum bodyTypeEnum);
NewRecord.BodyType = bodyTypeEnum;
Enum.TryParse <GearBoxTypeEnum>(cbGearType.SelectedValue.ToString(), out GearBoxTypeEnum gearBoxTypeEnum);
NewRecord.GearBoxType = gearBoxTypeEnum;
double.TryParse(txtBoxPrice.Text, out double price);
NewRecord.Price = price;
//Save the data to DB
DB.ModelDetail.Add(NewRecord);
DB.SaveChanges();
//Reset Form
this.ResetForm();
}
public async Task <bool> UpdateModelDetail(ModelDetail entity)
{
try
{
_dataRepositories.ModelDetailRepository.Edit(entity);
_dataRepositories.ModelDetailRepository.Save();
return(await Task.FromResult(true));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
// PUT api/modeldetailapi/5
public async Task <bool> Put(Guid id, ModelDetail modeldetail)
{
var result = await _dataServices.ModelDetailService.UpdateModelDetail(modeldetail);
if (!result)
{
return(await Task.Run(() => false));
}
//modeldetail.PartNumber.ModelDetail = null;
//SignalR Methods Update
var context = GlobalHost.ConnectionManager.GetHubContext <ModelDetailHub>();
context.Clients.All.UpdateModelDetail(modeldetail);
var task = Task.Run(() => true);
return(await task);
}
// POST api/modeldetailapi
public async Task <ModelDetail> Post(ModelDetail modeldetail)
{
var result = await _dataServices.ModelDetailService.CreateModelDetail(modeldetail);
if (!result)
{
return(null);
}
//modeldetail.PartNumber = await _dataServices.PartNumberService.GetPartNumberById(modeldetail.PartNumberId);
//SignalR Methods Add Element
var context = GlobalHost.ConnectionManager.GetHubContext <ModelDetailHub>();
context.Clients.All.CreateModelDetail(modeldetail);
var task = Task.Run(() => modeldetail);
return(await task);
}
public async Task <bool> CreateModelDetail(ModelDetail entity)
{
try
{
var result = false;
_dataRepositories.ModelDetailRepository.Add(entity);
_dataRepositories.ModelDetailRepository.Save();
if (entity.ModelDetailId != Guid.NewGuid())
{
result = true;
}
return(await Task.FromResult(result));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
protected override void GenerateSelectProperties(Graph graph, ModelDetail modelDetail, ref CharWriteBuffer sb)
{
//AppendLineBreak(ref sb);
if (graph.IncludeAllProperties)
{
sb.Write('`');
sb.Write(modelDetail.DataSourceEntityName);
sb.Write("`.*");
AppendLineBreak(ref sb);
}
else
{
var passedfirst = false;
foreach (var property in graph.LocalProperties)
{
if (modelDetail.TryGetProperty(property, out ModelPropertyDetail modelProperty))
{
if (modelProperty.PropertySourceName != null && modelProperty.ForeignIdentity == null)
{
if (passedfirst)
{
sb.Write(',');
}
else
{
passedfirst = true;
}
sb.Write('`');
sb.Write(modelDetail.DataSourceEntityName);
sb.Write("`.`");
sb.Write(property);
sb.Write('`');
AppendLineBreak(ref sb);
}
}
}
if (!passedfirst)
{
sb.Write(" 1");
}
}
}
protected override void GenerateEnding(QueryOperation select, Graph graph, ModelDetail modelDetail, ref CharWriteBuffer sb)
{
switch (select)
{
case QueryOperation.Many:
break;
case QueryOperation.First:
sb.Write("LIMIT 1");
break;
case QueryOperation.Single:
sb.Write("LIMIT 2");
break;
case QueryOperation.Count:
break;
case QueryOperation.Any:
sb.Write("LIMIT 1");
break;
}
}
protected override void GenerateEnding(QueryOperation select, Graph graph, ModelDetail modelDetail, ref CharWriteBuffer sb)
{
}
public ContentDetailController()
{
_detailContext = new MyWebContext();
_commentTable = new CommentsTable();
_modelDetail = new ModelDetail();
}
public string ConvertInternal(QueryOperation select, Expression where, QueryOrder order, int?skip, int?take, Graph graph, ModelDetail modelDetail)
{
var operationContext = new MemberContext();
var sb = new CharWriteBuffer();
try
{
Convert(ref sb, select, where, order, skip, take, graph, modelDetail, operationContext);
return(sb.ToString());
}
finally
{
sb.Dispose();
}
}
/// <summary>
/// Creates a new modelDetail object
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private ModelDetail CreateModelDetail(System.Type type, bool hasMetadata, string defaultDescription = null)
{
var detail = new ModelDetail
{
Name = type.GetName(),
HasMetadata = hasMetadata,
IsBasicType = Utilities.DefaultValueGenerator.IsBasicType(type),
Description = defaultDescription,
ModelType = type,
};
if (IsArrayOrEnumerableSingle(type))
{
var innerType = type.IsArray ? type.GetElementType() : type.GetGenericArguments()[0];
detail.ArrayDetail = CreateModelDetail(innerType);
detail.IsArray = true;
detail.Name = string.Format("Array[{0}]", innerType.GetName());
}
var descriptionAttr = (System.ComponentModel.DescriptionAttribute)(type.GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), true).FirstOrDefault());
if (descriptionAttr != null) detail.Description = descriptionAttr.Description;
try
{
object modelSample = Utilities.DefaultValueGenerator.GetSampleInstance(type);
if (Formatter.JSON != null)
{
try
{
detail.SampleJson = Formatter.JSON.Serialize(modelSample, true);
}
catch (Exception ex)
{
detail.SampleJson = "Error: " + ex.Message;
}
}
if (Formatter.XML != null)
{
try
{
detail.SampleXml = Formatter.XML.Serialize(modelSample, true);
}
catch (Exception ex)
{
detail.SampleXml = "Error: " + ex.Message;
}
}
try
{
detail.SampleCSharp = GetCSharpCode(type);
}
catch (Exception ex)
{
detail.SampleCSharp = "Error: " + ex.Message;
}
}
catch (Exception ex)
{
// todo: log error generating sample
detail.SampleJson = "Error Creating Sample: " + ex.Message;
detail.SampleXml = "Error Creating Sample: " + ex.Message;
detail.SampleCSharp = "Error Creating Sample: " + ex.ToString();
}
return detail;
}
protected override void ConvertToSqlParameterModel(ModelDetail modelDetail, ref CharWriteBuffer sb, BuilderContext context, bool parameterInContext)
{
var member = context.MemberContext.MemberAccessStack.Pop();
var modelProperty = modelDetail.GetProperty(member.Member.Name);
if (modelProperty.IsDataSourceEntity && context.MemberContext.MemberAccessStack.Count > 0)
{
var subModelInfo = ModelAnalyzer.GetModel(modelProperty.InnerType);
context.MemberContext.ModelStack.Push(subModelInfo);
if (parameterInContext)
{
var parentDependant = context.MemberContext.DependantStack.Peek();
if (!parentDependant.Dependants.TryGetValue(subModelInfo.Type, out ParameterDependant dependant))
{
dependant = new ParameterDependant(subModelInfo, modelProperty);
parentDependant.Dependants.Add(subModelInfo.Type, dependant);
}
context.MemberContext.DependantStack.Push(dependant);
}
ConvertToSqlParameterModel(subModelInfo, ref sb, context, parameterInContext);
if (parameterInContext)
{
context.MemberContext.DependantStack.Pop();
}
context.MemberContext.ModelStack.Pop();
}
else if (context.MemberContext.InCallNoRender > 0)
{
}
else if (context.MemberContext.InCallRenderIdentity > 0)
{
if (modelDetail.IdentityProperties.Count != 1)
{
throw new NotSupportedException($"Relational queries support only one identity on {modelDetail.Type.GetNiceName()}");
}
var modelIdentity = modelDetail.IdentityProperties[0];
sb.Write('`');
sb.Write(modelDetail.DataSourceEntityName);
sb.Write("`.`");
sb.Write(modelIdentity.PropertySourceName);
sb.Write("`");
}
else
{
bool closeBrace = false;
if (context.MemberContext.MemberAccessStack.Count > 0)
{
bool memberPropertyHandled = false;
var memberProperty = context.MemberContext.MemberAccessStack.Pop();
if (member.Type.Name == typeof(Nullable <>).Name && memberProperty.Member.Name == "Value")
{
memberPropertyHandled = true;
}
else if (member.Type == typeof(DateTime))
{
memberPropertyHandled = true;
closeBrace = true;
switch (memberProperty.Member.Name)
{
case "Year":
sb.Write("YEAR(");
break;
case "Month":
sb.Write("MONTH(");
break;
case "Day":
sb.Write("DAY(day,");
break;
case "Hour":
sb.Write("HOUR(");
break;
case "Minute":
sb.Write("MINUTE(");
break;
case "Second":
sb.Write("SECOND(");
break;
case "Millisecond":
sb.Write("1/1000*MICROSECOND(");
break;
case "DayOfYear":
sb.Write("DAYOFYEAR(");
break;
case "DayOfWeek":
sb.Write("WEEKDAY(");
break;
default:
memberPropertyHandled = false;
break;
}
}
if (!memberPropertyHandled)
{
throw new NotSupportedException($"{member.Member.Name}.{memberProperty.Member.Name} not supported");
}
context.MemberContext.MemberAccessStack.Push(memberProperty);
}
sb.Write('`');
sb.Write(modelDetail.DataSourceEntityName);
sb.Write('`');
sb.Write('.');
sb.Write('`');
sb.Write(modelProperty.PropertySourceName);
sb.Write('`');
var lastOperator = context.MemberContext.OperatorStack.Peek();
if (lastOperator == Operator.And || lastOperator == Operator.Or)
{
if (modelProperty.InnerType == typeof(bool))
{
sb.Write("=1");
}
else
{
sb.Write("IS NOT NULL");
}
}
if (closeBrace)
{
sb.Write(')');
}
}
context.MemberContext.MemberAccessStack.Push(member);
}
public static string Convert(QueryOperation select, Expression where, QueryOrder order, int?skip, int?take, Graph graph, ModelDetail modelDetail)
{
return(instance.ConvertInternal(select, where, order, skip, take, graph, modelDetail));
}
protected void Convert(ref CharWriteBuffer sb, QueryOperation select, Expression where, QueryOrder order, int?skip, int?take, Graph graph, ModelDetail modelDetail, MemberContext operationContext)
{
var hasWhere = where != null;
var hasOrderSkipTake = (select == QueryOperation.Many || select == QueryOperation.First) && (order?.OrderExpressions.Length > 0 || skip > 0 || take > 0);
GenerateSelect(select, graph, modelDetail, ref sb);
GenerateFrom(modelDetail, ref sb);
if (hasWhere || hasOrderSkipTake)
{
var rootDependant = new ParameterDependant(modelDetail, null);
var sbWhereOrder = new CharWriteBuffer();
try
{
if (hasWhere)
{
GenerateWhere(where, ref sbWhereOrder, rootDependant, operationContext);
}
if (hasOrderSkipTake)
{
GenerateOrderSkipTake(order, skip, take, ref sbWhereOrder, rootDependant, operationContext);
}
GenerateJoin(rootDependant, ref sb);
sb.Write(sbWhereOrder);
}
finally
{
sbWhereOrder.Dispose();
}
}
GenerateEnding(select, graph, modelDetail, ref sb);
}
protected abstract void ConvertToSqlParameterModel(ModelDetail modelDetail, ref CharWriteBuffer sb, BuilderContext context, bool parameterInContext);
public ParameterDependant(ModelDetail modelDetail, ModelPropertyDetail parentMember)
{
this.ModelDetail = modelDetail;
this.ParentMember = parentMember;
this.Dependants = new Dictionary <Type, ParameterDependant>();
}
