public static RoutineModel copyRoutineToModel(Routine r)
{
if (r == null)
{
return(null);
}
RoutineModel newRoutine = new RoutineModel()
{
expectedDuration = r.expectedDuration,
isNotifiable = r.isNotifiable,
isTimed = r.isTimed,
routineTitle = r.routineTitle,
assigneeUserName = r.assigneeUserName,
isDisabled = r.isDisabled,
};
foreach (Task t in r.Tasks)
{
newRoutine.Tasks.Add(copyTaskToModel(t));
}
foreach (Feedback f in r.Feedbacks)
{
newRoutine.Feedbacks.Add(copyFeedbackToModel(f));
}
return(newRoutine);
}
private static string GenerateMultiResultStatement(Routine procedure, RoutineModel model, bool useAsyncCalls)
{
if (procedure.Results.Count == 1)
{
return(null);
}
var ids = new List <string>();
int i = 1;
foreach (var resultSet in procedure.Results)
{
var suffix = $"{i++}";
var typeName = GenerateIdentifierName(procedure, model) + "Result" + suffix;
if (useAsyncCalls)
{
ids.Add($"(await reader.ReadAsync<{typeName}>()).ToList()");
}
else
{
ids.Add($"(reader.Read<{typeName}>()).ToList()");
}
}
return($"({string.Join(", ", ids)})");
}
/* Creates a new routine for the given user from
* the given model.
* @param creatorUsername: The username of the
* user who created the routine.
* @param model: The model of the routine to create
* from.
*/
public void createRoutine(string creatorUsername, RoutineModel model)
{
Routine r = new Routine()
{
assigneeUserName = model.assigneeUserName,
creatorUserName = creatorUsername,
expectedDuration = model.expectedDuration,
isDisabled = model.isDisabled,
isNotifiable = model.isNotifiable,
isTimed = model.isTimed,
routineTitle = model.routineTitle,
updatedDate = DateTime.Now
};
r = helper.createRoutine(r);
foreach (TaskModel t in model.Tasks)
{
taskHelper.createTask(r.routineID, t);
}
foreach (FeedbackModel f in model.Feedbacks)
{
feedbackHelper.createRoutineFeedback(r.routineID, f);
}
}
private void GenerateOnModelCreating(RoutineModel model)
{
Sb.AppendLine();
Sb.AppendLine("protected void OnModelCreatingGeneratedProcedures(ModelBuilder modelBuilder)");
Sb.AppendLine("{");
using (Sb.Indent())
{
foreach (var procedure in model.Routines.Cast <Procedure>())
{
if (procedure.NoResultSet)
{
continue;
}
int i = 1;
foreach (var resultSet in procedure.Results)
{
var suffix = $"{i++}";
if (!procedure.SupportsMultipleResultSet)
{
suffix = string.Empty;
}
var typeName = GenerateIdentifierName(procedure, model) + "Result" + suffix;
Sb.AppendLine($"modelBuilder.Entity<{typeName}>().HasNoKey().ToView(null);");
}
}
}
Sb.AppendLine("}");
}
private void GenerateFunctionStub(Routine function, RoutineModel model)
{
var paramStrings = function.Parameters
.Select(p => $"{code.Reference(p.ClrType())} {p.Name}");
var identifier = GenerateIdentifierName(function, model);
_sb.AppendLine();
_sb.AppendLine($"[DbFunction(\"{function.Name}\", \"{function.Schema}\")]");
if ((function as Function) !.IsScalar)
{
var returnType = paramStrings.First();
var parameters = string.Empty;
if (function.Parameters.Count > 1)
{
parameters = string.Join(", ", paramStrings.Skip(1));
}
_sb.AppendLine($"public static {returnType}{identifier}({parameters})");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine("throw new NotSupportedException(\"This method can only be called from Entity Framework Core queries\");");
}
_sb.AppendLine("}");
}
protected string GenerateIdentifierName(Routine routine, RoutineModel model)
{
if (routine == null)
{
throw new ArgumentNullException(nameof(routine));
}
return(CreateIdentifier(GenerateUniqueName(routine, model)).Item1);
}
public ScaffoldedModel ScaffoldModel(RoutineModel model, ModuleScaffolderOptions scaffolderOptions, ref List <string> errors)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var result = new ScaffoldedModel();
errors = model.Errors;
foreach (var routine in model.Routines.Where(r => !(r is Function f) || !f.IsScalar))
{
int i = 1;
foreach (var resultSet in routine.Results)
{
var suffix = string.Empty;
if (routine.Results.Count > 1)
{
suffix = $"{i++}";
}
var typeName = GenerateIdentifierName(routine, model) + "Result" + suffix;
var classContent = WriteResultClass(resultSet, scaffolderOptions, typeName);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = scaffolderOptions.UseSchemaFolders
? Path.Combine(routine.Schema, $"{typeName}.cs")
: $"{typeName}.cs"
});
}
}
var dbContext = WriteDbContext(scaffolderOptions, model);
var fileNameSuffix = this switch
{
SqlServerStoredProcedureScaffolder _ => "Procedures",
SqlServerFunctionScaffolder _ => ".Functions",
_ => throw new InvalidOperationException($"Unknown type '{GetType().Name}'"),
};
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(scaffolderOptions.ContextDir, scaffolderOptions.ContextName + $"{fileNameSuffix}.cs")),
};
return(result);
}
public Task <int> SaveItemAsync(RoutineModel obj)
{
if (obj.RoutineID != 0)
{
return(db.UpdateAsync(obj));
}
else
{
return(db.InsertAsync(obj));
}
}
public void modifyExistingRoutine(string routineName, RoutineModel model)
{
Routine rout = getRoutineAssignedToByName(routineName);
rout.isTimed = model.isTimed;
rout.expectedDuration = model.expectedDuration;
rout.isNotifiable = model.isNotifiable;
rout.isDisabled = model.isDisabled;
rout.updatedDate = DateTime.Now;
taskHelper.modifyExistingTasks(rout.Tasks.ToList(), model.Tasks.ToList(), true);
feedbackHelper.updateRoutineFeedbacks(rout.routineID, model.Feedbacks.ToList());
helper.updateRoutine(rout);
}
public ActionResult Edit(RoutineModel model, string routineName, string mockUser = "")
{
if (!(Roles.IsUserInRole("Administrator") || Roles.IsUserInRole("Job Coach") || Roles.IsUserInRole("Parent")))
{
Response.Redirect("~/Unauthorized");
return(View());
}
if (!ModelState.IsValid)
{
EnumHelper enumhelp = new EnumHelper();
ViewData["TaskCategories"] = enumhelp.getAllTaskCategoryNames().ToList();
ViewData["FeedbackTypes"] = enumhelp.getAllFeedbackTypeNames().ToList();
ViewData["MediaTypes"] = enumhelp.getAllMediaTypeNames().ToList();
ViewData["mockUser"] = mockUser;
return(View(model));
}
if (Roles.IsUserInRole("Administrator"))
{
if (mockUser == null || mockUser.Equals("") || !accountHelper.userExists(mockUser))
{
Response.Redirect("~/Routine");
return(View());
}
else
{
if (!helper.routineExists(mockUser, routineName, model.assigneeUserName))
{
return(HttpNotFound());
}
helper.updateRoutine(mockUser, routineName, model);
return(RedirectToAction("List", "Routine", new { mockUser = mockUser }));
}
}
if (!helper.routineExists(routineName, model.assigneeUserName))
{
return(HttpNotFound());
}
helper.updateRoutine(routineName, model);
return(RedirectToAction("List"));
}
private string GenerateUniqueName(Routine routine, RoutineModel model)
{
if (!string.IsNullOrEmpty(routine.NewName))
{
return(routine.NewName);
}
var numberOfNames = model.Routines.Where(p => p.Name == routine.Name).Count();
if (numberOfNames > 1)
{
return(routine.Name + CultureInfo.InvariantCulture.TextInfo.ToTitleCase(routine.Schema));
}
return(routine.Name);
}
private void GenerateModelCreation(RoutineModel model)
{
_sb.AppendLine();
_sb.AppendLine("protected void OnModelCreatingGeneratedFunctions(ModelBuilder modelBuilder)");
_sb.AppendLine("{");
using (_sb.Indent())
{
foreach (var function in model.Routines.Cast <Function>().Where(f => !f.IsScalar))
{
var typeName = GenerateIdentifierName(function, model) + "Result";
_sb.AppendLine($"modelBuilder.Entity<{typeName}>().HasNoKey();");
}
}
_sb.AppendLine("}");
}
/* Updates the most recent routine created by the
* given user that matches the given name. Creates
* a new routine if no routine matches the given
* name or if the matched routine already has jobs
* associated with it.
* @param creatorUsername: The username of the
* user who is to be the creator of the routine.
* @param routineName: The routine name to match.
* @param model: The model to update or create
* a routine from.
*/
public void updateRoutine(string creatorUsername, string routineName, RoutineModel model)
{
if (!routineExists(creatorUsername, routineName, model.assigneeUserName))
{
createRoutine(creatorUsername, model);
}
if (routineHasJobs(creatorUsername, routineName, model.assigneeUserName))
{ // Cannot edit routines that have existing jobs
//Except if times are same and steps are still in same order
//TODO add check for similarity
disableAllRoutinesByName(creatorUsername, routineName, model.assigneeUserName);
createRoutine(creatorUsername, model);
}
else
{
modifyExistingRoutine(creatorUsername, routineName, model);
}
}
private static string GenerateMultiResultId(Routine procedure, RoutineModel model)
{
if (procedure.Results.Count == 1)
{
return(null);
}
var ids = new List <string>();
int i = 1;
foreach (var resultSet in procedure.Results)
{
var suffix = $"{i++}";
var typeName = GenerateIdentifierName(procedure, model) + "Result" + suffix;
ids.Add($"List<{typeName}> Result{suffix}");
}
return($"({string.Join(", ", ids)})");
}
public RoutineModel GetRoutineInfo(string token, string username, string routineTitle)
{
RoutineModel routineInfo = new RoutineModel();
if (username == null)
{
return(null);
}
auth.authorizeToken(token);
//UserInfoModel temp = helper.getRoutineInfo(username);
//userInfo.Add(temp.userName);
//userInfo.Add(temp.phone);
//userInfo.Add(temp.email);
Routine temp = helper.getRoutineAssignedToByName(routineTitle);
//routineInfo = (RoutineModel) temp;
return(routineInfo);
}
public async Task <bool> SaveRoutine()
{
DateTime dateTime = DateTime.Now;
if (!string.IsNullOrEmpty(_applicationType) || !string.IsNullOrEmpty(_note) || !string.IsNullOrEmpty(_daytype) || _time == null)
{
RoutineModel routine = new RoutineModel()
{
RoutineType = _applicationType,
Date = DateTime.Now,
Color = "Gold",
DaySelection = _daytype,
Time = _time,
Notes = _note,
MoreInfos = new ObservableCollection <MoreInfo> {
new MoreInfo {
Notes = _note, Time = _time
}
}
};
//Add New Usage
await App.SQLiteDb.SaveItemAsync(routine);
ApplicationType = string.Empty;
Note = string.Empty;
DayType = string.Empty;
await PopupNavigation.Instance.PushAsync(new MessageModal("Added Routine"), true);
return(true);
}
else
{
await PopupNavigation.Instance.PushAsync(new MessageModal("Whoops!! Please try again"), true);
return(false);
}
}
public HttpResponseMessage PostRoutine(PostRoutineRequest data)
{
string token = data.token;
string create = data.create;
PJCAdmin.Classes.Helpers.MVCModelHelpers.RoutineHelper helper = new Classes.Helpers.MVCModelHelpers.RoutineHelper();
RoutineModel routine = Json.Decode <RoutineModel>(data.model.ToString());
switch (create)
{
case "c": //create new job
//create the model in the database
helper.createRoutine(auth.getUserNameFromToken(token), routine);
break;
case "m": //modify existing job
//find the routine that matches
//update the database for routine
try
{
helper.modifyExistingRoutine(auth.getUserNameFromToken(token), routine.routineTitle, routine);
}catch (InvalidOperationException)
{
helper.updateRoutine(auth.getUserNameFromToken(token), routine.routineTitle, routine);
}
break;
case "d": //delete existing job
//find the routine that matches
//delete the matching routine from the database
helper.deleteRoutine(auth.getUserNameFromToken(token), routine.routineTitle, routine.assigneeUserName, false);
return(Request.CreateResponse <string>(HttpStatusCode.OK, "Job Deleted"));
default: return(Request.CreateResponse <string>(HttpStatusCode.BadRequest, "Create Code Not Recognized"));
}
return(Request.CreateResponse <string>(HttpStatusCode.Created, "Job Created"));
}
protected override string WriteDbContextInterface(ModuleScaffolderOptions scaffolderOptions, RoutineModel model)
{
if (scaffolderOptions is null)
{
throw new ArgumentNullException(nameof(scaffolderOptions));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
Sb = new IndentedStringBuilder();
Sb.AppendLine(PathHelper.Header);
var usings = CreateUsings(scaffolderOptions, model);
foreach (var statement in usings)
{
Sb.AppendLine($"{statement};");
}
Sb.AppendLine();
Sb.AppendLine($"namespace {scaffolderOptions.ContextNamespace}");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"public partial interface I{scaffolderOptions.ContextName}Procedures");
Sb.AppendLine("{");
using (Sb.Indent())
{
foreach (var procedure in model.Routines)
{
GenerateProcedure(procedure, model, true, scaffolderOptions.UseAsyncCalls);
Sb.AppendLine(";");
}
}
Sb.AppendLine("}");
}
Sb.AppendLine("}");
return(Sb.ToString());
}
/* Updates the most recent routine created by the
* currently logged in user that matches the given
* name. Creates a new routine if no routine matches
* the given name or if the matched routine already
* has jobs associated with it.
* @param routineName: The routine name to match.
* @param model: The model to update or create
* a routine from.
*/
public void updateRoutine(string routineName, RoutineModel model)
{
updateRoutine(AccountHelper.getCurrentUsername(), routineName, model);
}
protected override string WriteDbContext(ModuleScaffolderOptions scaffolderOptions, RoutineModel model)
{
_sb = new IndentedStringBuilder();
_sb.AppendLine(PathHelper.Header);
_sb.AppendLine("using Microsoft.EntityFrameworkCore;");
_sb.AppendLine("using System;");
_sb.AppendLine("using System.Linq;");
_sb.AppendLine($"using {scaffolderOptions.ModelNamespace};");
_sb.AppendLine();
_sb.AppendLine($"namespace {scaffolderOptions.ContextNamespace}");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"public partial class {scaffolderOptions.ContextName}");
_sb.AppendLine("{");
using (_sb.Indent())
{
foreach (var function in model.Routines)
{
GenerateFunctionStub(function, model);
}
GenerateModelCreation(model);
}
_sb.AppendLine("}");
}
_sb.AppendLine("}");
return(_sb.ToString());
}
public ScaffoldedModel ScaffoldModel(RoutineModel model, ModuleScaffolderOptions scaffolderOptions, ref List <string> errors)
{
throw new NotSupportedException();
}
protected override string WriteDbContext(ModuleScaffolderOptions scaffolderOptions, RoutineModel model)
{
if (scaffolderOptions is null)
{
throw new ArgumentNullException(nameof(scaffolderOptions));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
Sb = new IndentedStringBuilder();
Sb.AppendLine(PathHelper.Header);
Sb.AppendLine("using Microsoft.EntityFrameworkCore;");
Sb.AppendLine("using System;");
Sb.AppendLine("using System.Data;");
Sb.AppendLine("using System.Linq;");
Sb.AppendLine($"using {scaffolderOptions.ModelNamespace};");
if (model.Routines.SelectMany(r => r.Parameters).Any(p => p.ClrType() == typeof(Geometry)))
{
Sb.AppendLine("using NetTopologySuite.Geometries;");
}
Sb.AppendLine();
Sb.AppendLine($"namespace {scaffolderOptions.ContextNamespace}");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"public partial class {scaffolderOptions.ContextName}");
Sb.AppendLine("{");
using (Sb.Indent())
{
foreach (var function in model.Routines)
{
GenerateFunctionStub(function, model);
}
GenerateModelCreation(model);
}
Sb.AppendLine("}");
}
Sb.AppendLine("}");
return(Sb.ToString());
}
/* Updates the most recent routine created by the
* given user that matches the given name, using
* the given model.
* @param creatorUsername: The username of the
* user who created the routine.
* @param routineName: The routine name to match.
* @param model: The model to use for updating
* the existing routine.
*/
private void modifyExistingRoutine(string creatorUsername, string routineName, RoutineModel model)
{
Routine r = getMostRecentRoutineAssignedToByName(creatorUsername, routineName, model.assigneeUserName);
r.isTimed = model.isTimed;
r.expectedDuration = model.expectedDuration;
r.isNotifiable = model.isNotifiable;
r.isDisabled = model.isDisabled;
r.updatedDate = DateTime.Now;
taskHelper.modifyExistingTasks(r.Tasks.ToList(), model.Tasks.ToList(), true);
feedbackHelper.updateRoutineFeedbacks(r.routineID, model.Feedbacks.ToList());
helper.updateRoutine(r);
}
protected override string WriteDbContext(ModuleScaffolderOptions scaffolderOptions, RoutineModel model)
{
if (scaffolderOptions is null)
{
throw new ArgumentNullException(nameof(scaffolderOptions));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
Sb = new IndentedStringBuilder();
Sb.AppendLine(PathHelper.Header);
var usings = CreateUsings(scaffolderOptions, model);
foreach (var statement in usings)
{
Sb.AppendLine($"{statement};");
}
Sb.AppendLine();
Sb.AppendLine($"namespace {scaffolderOptions.ContextNamespace}");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"public partial class {scaffolderOptions.ContextName}");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"private I{scaffolderOptions.ContextName}Procedures _procedures;");
Sb.AppendLine();
Sb.AppendLine($"public virtual I{scaffolderOptions.ContextName}Procedures Procedures");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine("get");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"if (_procedures is null) _procedures = new {scaffolderOptions.ContextName}Procedures(this);");
Sb.AppendLine("return _procedures;");
}
Sb.AppendLine("}");
Sb.AppendLine("set");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine("_procedures = value;");
}
Sb.AppendLine("}");
}
Sb.AppendLine("}");
Sb.AppendLine();
Sb.AppendLine($"public I{scaffolderOptions.ContextName}Procedures GetProcedures()");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine("return Procedures;");
}
Sb.AppendLine("}");
GenerateOnModelCreating(model);
}
Sb.AppendLine("}");
Sb.AppendLine();
Sb.AppendLine($"public partial class {scaffolderOptions.ContextName}Procedures : I{scaffolderOptions.ContextName}Procedures");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"private readonly {scaffolderOptions.ContextName} _context;");
Sb.AppendLine();
Sb.AppendLine($"public {scaffolderOptions.ContextName}Procedures({scaffolderOptions.ContextName} context)");
Sb.AppendLine("{");
using (Sb.Indent())
{
Sb.AppendLine($"_context = context;");
}
Sb.AppendLine("}");
}
foreach (var procedure in model.Routines)
{
GenerateProcedure(procedure, model, false, scaffolderOptions.UseAsyncCalls);
}
if (model.Routines.Any(r => r.SupportsMultipleResultSet))
{
GenerateDapperSupport(scaffolderOptions.UseAsyncCalls);
}
Sb.AppendLine("}");
}
Sb.AppendLine("}");
return(Sb.ToString());
}
private void GenerateProcedure(Routine procedure, RoutineModel model, bool signatureOnly, bool useAsyncCalls)
{
var paramStrings = procedure.Parameters.Where(p => !p.Output)
.Select(p => $"{Code.Reference(p.ClrType(asMethodParameter: true))} {Code.Identifier(p.Name)}")
.ToList();
var allOutParams = procedure.Parameters.Where(p => p.Output).ToList();
var outParams = allOutParams.SkipLast(1).ToList();
var retValueName = allOutParams.Last().Name;
var outParamStrings = outParams
.Select(p => $"OutputParameter<{Code.Reference(p.ClrType())}> {Code.Identifier(p.Name)}")
.ToList();
string fullExec = GenerateProcedureStatement(procedure, retValueName, useAsyncCalls);
var multiResultId = GenerateMultiResultId(procedure, model);
var identifier = GenerateIdentifierName(procedure, model);
var returnClass = identifier + "Result";
if (!string.IsNullOrEmpty(procedure.MappedType))
{
returnClass = procedure.MappedType;
}
var line = GenerateMethodSignature(procedure, outParams, paramStrings, retValueName, outParamStrings, identifier, multiResultId, signatureOnly, useAsyncCalls, returnClass);
if (signatureOnly)
{
Sb.Append(line);
return;
}
using (Sb.Indent())
{
Sb.AppendLine();
Sb.AppendLine(line);
Sb.AppendLine("{");
using (Sb.Indent())
{
foreach (var parameter in allOutParams)
{
GenerateParameterVar(parameter, procedure);
}
Sb.AppendLine();
Sb.AppendLine("var sqlParameters = new []");
Sb.AppendLine("{");
using (Sb.Indent())
{
foreach (var parameter in procedure.Parameters)
{
if (parameter.Output)
{
Sb.Append($"{ParameterPrefix}{parameter.Name}");
}
else
{
GenerateParameter(parameter, procedure);
}
Sb.AppendLine(",");
}
}
Sb.AppendLine("};");
if (procedure.HasValidResultSet && (procedure.Results.Count == 0 || procedure.Results[0].Count == 0))
{
Sb.AppendLine(useAsyncCalls
? $"var _ = await _context.Database.ExecuteSqlRawAsync({fullExec});"
: $"var _ = _context.Database.ExecuteSqlRaw({fullExec});");
}
else
{
if (procedure.SupportsMultipleResultSet)
{
Sb.AppendLine();
Sb.AppendLine("var dynamic = CreateDynamic(sqlParameters);");
Sb.AppendLine($"{multiResultId} _;");
Sb.AppendLine();
Sb.AppendLine($"using (var reader = {(useAsyncCalls ? "await GetMultiReaderAsync" : "GetMultiReader")}(_context, dynamic, \"[{procedure.Schema}].[{procedure.Name}]\"))");
Sb.AppendLine("{");
using (Sb.Indent())
{
var statements = GenerateMultiResultStatement(procedure, model, useAsyncCalls);
Sb.AppendLine($"_ = {statements};");
}
Sb.AppendLine("}");
}
else
{
Sb.AppendLine(useAsyncCalls
? $"var _ = await _context.SqlQueryAsync<{returnClass}>({fullExec});"
: $"var _ = _context.SqlQuery<{returnClass}>({fullExec});");
}
}
Sb.AppendLine();
foreach (var parameter in outParams)
{
Sb.AppendLine($"{Code.Identifier(parameter.Name)}.SetValue({ParameterPrefix}{parameter.Name}.Value);");
}
if (procedure.SupportsMultipleResultSet)
{
Sb.AppendLine($"{retValueName}?.SetValue(dynamic.Get<int>(\"{retValueName}\"));");
}
else
{
Sb.AppendLine($"{retValueName}?.SetValue({ParameterPrefix}{retValueName}.Value);");
}
Sb.AppendLine();
Sb.AppendLine("return _;");
}
Sb.AppendLine("}");
}
}
private void GenerateProcedure(Routine procedure, RoutineModel model)
{
var paramStrings = procedure.Parameters.Where(p => !p.Output)
.Select(p => $"{code.Reference(p.ClrType())} {p.Name}")
.ToList();
var allOutParams = procedure.Parameters.Where(p => p.Output).ToList();
var outParams = allOutParams.SkipLast(1).ToList();
var retValueName = allOutParams.Last().Name;
var outParamStrings = outParams
.Select(p => $"OutputParameter<{code.Reference(p.ClrType())}> {p.Name}")
.ToList();
string fullExec = GenerateProcedureStatement(procedure, retValueName);
var identifier = GenerateIdentifierName(procedure, model);
var line = GenerateMethodSignature(procedure, outParams, paramStrings, retValueName, outParamStrings, identifier);
using (_sb.Indent())
{
_sb.AppendLine();
_sb.AppendLine(line);
_sb.AppendLine("{");
using (_sb.Indent())
{
foreach (var parameter in allOutParams)
{
GenerateParameterVar(parameter);
}
_sb.AppendLine();
_sb.AppendLine("var sqlParameters = new []");
_sb.AppendLine("{");
using (_sb.Indent())
{
foreach (var parameter in procedure.Parameters)
{
if (parameter.Output)
{
_sb.Append($"{parameterPrefix}{parameter.Name}");
}
else
{
GenerateParameter(parameter);
}
_sb.AppendLine(",");
}
}
_sb.AppendLine("};");
if (procedure.HasValidResultSet && procedure.ResultElements.Count == 0)
{
_sb.AppendLine($"var _ = await _context.Database.ExecuteSqlRawAsync({fullExec});");
}
else
{
_sb.AppendLine($"var _ = await _context.SqlQueryAsync<{identifier}Result>({fullExec});");
}
_sb.AppendLine();
foreach (var parameter in outParams)
{
_sb.AppendLine($"{parameter.Name}.SetValue({parameterPrefix}{parameter.Name}.Value);");
}
_sb.AppendLine($"{retValueName}?.SetValue({parameterPrefix}{retValueName}.Value);");
_sb.AppendLine();
_sb.AppendLine("return _;");
}
_sb.AppendLine("}");
}
}
private static List <string> CreateUsings(ModuleScaffolderOptions scaffolderOptions, RoutineModel model)
{
var usings = new List <string>()
{
"using Microsoft.EntityFrameworkCore",
"using Microsoft.Data.SqlClient",
"using System",
"using System.Collections.Generic",
"using System.Data",
"using System.Threading",
"using System.Threading.Tasks",
$"using {scaffolderOptions.ModelNamespace}",
};
if (model.Routines.Any(r => r.SupportsMultipleResultSet))
{
usings.AddRange(new List <string>()
{
"using Dapper",
"using Microsoft.EntityFrameworkCore.Storage",
"using System.Linq",
});
}
if (model.Routines.SelectMany(r => r.Parameters).Any(p => p.ClrType() == typeof(Geometry)))
{
usings.AddRange(new List <string>()
{
"using NetTopologySuite.Geometries",
});
}
usings.Sort();
return(usings);
}
/* Creates a new routine for the currently logged in
* user from the given model.
* @param model: The model of the routine to create
* from.
*/
public void createRoutine(RoutineModel model)
{
createRoutine(AccountHelper.getCurrentUsername(), model);
}
protected override string WriteDbContext(ModuleScaffolderOptions procedureScaffolderOptions, RoutineModel model)
{
_sb = new IndentedStringBuilder();
_sb.AppendLine(PathHelper.Header);
_sb.AppendLine("using Microsoft.EntityFrameworkCore;");
_sb.AppendLine("using Microsoft.Data.SqlClient;");
_sb.AppendLine("using System;");
_sb.AppendLine("using System.Collections.Generic;");
//To support System.Data.DataTable
_sb.AppendLine("using System.Data;");
_sb.AppendLine("using System.Threading;");
_sb.AppendLine("using System.Threading.Tasks;");
_sb.AppendLine($"using {procedureScaffolderOptions.ModelNamespace};");
_sb.AppendLine();
_sb.AppendLine($"namespace {procedureScaffolderOptions.ContextNamespace}");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"public partial class {procedureScaffolderOptions.ContextName}");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"private {procedureScaffolderOptions.ContextName}Procedures _procedures;");
_sb.AppendLine();
_sb.AppendLine($"public virtual {procedureScaffolderOptions.ContextName}Procedures Procedures");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine("get");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"if (_procedures is null) _procedures = new {procedureScaffolderOptions.ContextName}Procedures(this);");
_sb.AppendLine("return _procedures;");
}
_sb.AppendLine("}");
_sb.AppendLine("set");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine("_procedures = value;");
}
_sb.AppendLine("}");
}
_sb.AppendLine("}");
_sb.AppendLine("");
_sb.AppendLine($"public {procedureScaffolderOptions.ContextName}Procedures GetProcedures()");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine("return Procedures;");
}
_sb.AppendLine("}");
}
_sb.AppendLine("}");
_sb.AppendLine();
_sb.AppendLine($"public partial class {procedureScaffolderOptions.ContextName}Procedures");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"private readonly {procedureScaffolderOptions.ContextName} _context;");
_sb.AppendLine();
_sb.AppendLine($"public {procedureScaffolderOptions.ContextName}Procedures({procedureScaffolderOptions.ContextName} context)");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"_context = context;");
}
_sb.AppendLine("}");
}
foreach (var procedure in model.Routines)
{
GenerateProcedure(procedure, model);
}
_sb.AppendLine("}");
}
_sb.AppendLine("}");
return(_sb.ToString());
}
protected abstract string WriteDbContext(ModuleScaffolderOptions scaffolderOptions, RoutineModel model);
