public ActionResult EditWizard([Bind(Include = "Id,ConcurrencyKey,ArgumentName,ArgumentValue,HostingEntity,flag,other,EntityDataSourceParametersID")] DataSourceParameters datasourceparameters, string UrlReferrer)
{
CheckBeforeSave(datasourceparameters);
if (ModelState.IsValid)
{
db.Entry(datasourceparameters).State = EntityState.Modified;
db.SaveChanges();
if (!string.IsNullOrEmpty(UrlReferrer))
{
var uri = new Uri(UrlReferrer);
var query = HttpUtility.ParseQueryString(uri.Query);
if (Convert.ToBoolean(query.Get("IsFilter")) == true)
{
return(RedirectToAction("Index"));
}
else
{
return(Redirect(UrlReferrer));
}
}
else
{
return(RedirectToAction("Index"));
}
}
LoadViewDataAfterOnEdit(datasourceparameters);
return(View(datasourceparameters));
}
protected async Task <IEnumerable <ItemResult> > CsvSaveImplementation(
string csv,
IDataSource <T> dataSource,
IBehaviors <T> behaviors,
bool hasHeader = true)
{
// Get list from CSV
var list = IntelliTect.Coalesce.Helpers.CsvHelper.ReadCsv <TDto>(csv, hasHeader);
var resultList = new List <ItemResult>();
foreach (var dto in list)
{
var parameters = new DataSourceParameters()
{
Includes = "none"
};
// Security: SaveImplementation is responsible for checking specific save/edit attribute permissions.
var result = await SaveImplementation(dto, parameters, dataSource, behaviors);
resultList.Add(new ItemResult {
WasSuccessful = result.WasSuccessful, Message = result.Message
});
}
return(resultList);
}
// GET: /DataSourceParameters/Edit/5
public ActionResult Edit(int?id, string UrlReferrer, string HostingEntityName, string AssociatedType)
{
if (!User.CanEdit("DataSourceParameters"))
{
return(RedirectToAction("Index", "Error"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DataSourceParameters datasourceparameters = db.DataSourceParameterss.Find(id);
if (datasourceparameters == null)
{
return(HttpNotFound());
}
if (UrlReferrer != null)
{
ViewData["DataSourceParametersParentUrl"] = UrlReferrer;
}
if (ViewData["DataSourceParametersParentUrl"] == null && Request.UrlReferrer != null && !Request.UrlReferrer.AbsolutePath.EndsWith("/DataSourceParameters") && !Request.UrlReferrer.AbsolutePath.EndsWith("/DataSourceParameters/Edit/" + datasourceparameters.Id + "") && !Request.UrlReferrer.AbsolutePath.EndsWith("/DataSourceParameters/Create"))
{
ViewData["DataSourceParametersParentUrl"] = Request.UrlReferrer;
}
ViewData["HostingEntityName"] = HostingEntityName;
ViewData["AssociatedType"] = AssociatedType;
LoadViewDataBeforeOnEdit(datasourceparameters);
ViewBag.DataSourceParametersIsHiddenRule = checkHidden("DataSourceParameters");
return(View(datasourceparameters));
}
// GET: /DataSourceParameters/EditWizard/5
public ActionResult EditWizard(int?id, string UrlReferrer)
{
if (!User.CanEdit("DataSourceParameters"))
{
return(RedirectToAction("Index", "Error"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DataSourceParameters datasourceparameters = db.DataSourceParameterss.Find(id);
if (datasourceparameters == null)
{
return(HttpNotFound());
}
if (UrlReferrer != null)
{
ViewData["DataSourceParametersParentUrl"] = UrlReferrer;
}
if (ViewData["DataSourceParametersParentUrl"] == null && Request.UrlReferrer != null && !Request.UrlReferrer.AbsolutePath.EndsWith("/DataSourceParameters"))
{
ViewData["DataSourceParametersParentUrl"] = Request.UrlReferrer;
}
LoadViewDataBeforeOnEdit(datasourceparameters);
ViewBag.DataSourceParametersIsHiddenRule = checkHidden("DataSourceParameters");
return(View(datasourceparameters));
}
public ActionResult EditQuick([Bind(Include = "Id,ConcurrencyKey,ArgumentName,ArgumentValue,HostingEntity,flag,other,EntityDataSourceParametersID")] DataSourceParameters datasourceparameters, string UrlReferrer, bool?IsAddPop, string AssociatedEntity)
{
CheckBeforeSave(datasourceparameters);
if (ModelState.IsValid)
{
string command = Request.Form["hdncommand"];
db.Entry(datasourceparameters).State = EntityState.Modified;
db.SaveChanges();
return(Json(UrlReferrer, "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
else
{
var errors = "";
foreach (ModelState modelState in ViewData.ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
errors += error.ErrorMessage + ". ";
}
}
return(Json(errors, "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
LoadViewDataAfterOnEdit(datasourceparameters);
return(View(datasourceparameters));
}
public ActionResult Create([Bind(Include = "Id,ConcurrencyKey,ArgumentName,ArgumentValue,HostingEntity,flag,other,EntityDataSourceParametersID")] DataSourceParameters datasourceparameters, string UrlReferrer, bool?IsDDAdd)
{
CheckBeforeSave(datasourceparameters);
if (ModelState.IsValid)
{
string command = Request.Form["hdncommand"];
db.DataSourceParameterss.Add(datasourceparameters);
db.SaveChanges();
if (command == "Create & Continue")
{
return(RedirectToAction("Edit", new { Id = datasourceparameters.Id, UrlReferrer = UrlReferrer }));
}
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
else
{
return(RedirectToAction("Index"));
}
}
if (IsDDAdd != null)
{
ViewBag.IsDDAdd = Convert.ToBoolean(IsDDAdd);
}
LoadViewDataAfterOnCreate(datasourceparameters);
return(View(datasourceparameters));
}
public ActionResult CreateQuick([Bind(Include = "Id,ConcurrencyKey,ArgumentName,ArgumentValue,HostingEntity,flag,other,EntityDataSourceParametersID")] DataSourceParameters datasourceparameters, string UrlReferrer, bool?IsAddPop, string AssociatedEntity)
{
CheckBeforeSave(datasourceparameters);
if (ModelState.IsValid)
{
db.DataSourceParameterss.Add(datasourceparameters);
db.SaveChanges();
return(Json("FROMPOPUP", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
else
{
var errors = "";
foreach (ModelState modelState in ViewData.ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
errors += error.ErrorMessage + ". ";
}
}
return(Json(errors, "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
LoadViewDataAfterOnCreate(datasourceparameters);
if (!string.IsNullOrEmpty(AssociatedEntity))
{
LoadViewDataForCount(datasourceparameters, AssociatedEntity);
}
return(View(datasourceparameters));
}
public ActionResult BulkUpdate([Bind(Include = "Id,ConcurrencyKey,ArgumentName,ArgumentValue,HostingEntity,flag,other,EntityDataSourceParametersID")] DataSourceParameters datasourceparameters, FormCollection collection, string UrlReferrer)
{
var bulkIds = collection["BulkUpdate"].Split(',').ToList();
var chkUpdate = collection["chkUpdate"];
if (!string.IsNullOrEmpty(chkUpdate))
{
foreach (var id in bulkIds.Where(p => p != string.Empty))
{
long objId = long.Parse(id);
DataSourceParameters target = db.DataSourceParameterss.Find(objId);
EntityCopy.CopyValuesForSameObjectType(datasourceparameters, target, chkUpdate);
db.Entry(target).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch { }
}
}
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
else
{
return(RedirectToAction("Index"));
}
}
public ActionResult DeleteConfirmed(DataSourceParameters datasourceparameters, string UrlReferrer)
{
if (!User.CanDelete("DataSourceParameters"))
{
return(RedirectToAction("Index", "Error"));
}
if (CheckBeforeDelete(datasourceparameters))
{
//Delete Document
db.Entry(datasourceparameters).State = EntityState.Deleted;
db.DataSourceParameterss.Remove(datasourceparameters);
db.SaveChanges();
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
if (ViewData["DataSourceParametersParentUrl"] != null)
{
string parentUrl = ViewData["DataSourceParametersParentUrl"].ToString();
ViewData["DataSourceParametersParentUrl"] = null;
return(Redirect(parentUrl));
}
else
{
return(RedirectToAction("Index"));
}
}
return(View(datasourceparameters));
}
public override long GetCount(DataSourceParameters queryParameters = null)
{
var source = Source;
using (var connection = GetOpenedConnection())
{
switch (source.TableType)
{
case TableType.Table:
{
return(Convert.ToInt64(CreateTableCountCommand(connection).ExecuteScalar()));
}
case TableType.View:
{
return(Convert.ToInt64(CreateViewCountCommand(connection).ExecuteScalar()));
}
case TableType.Function:
{
using (var command = CreateGetFunctionRecordsCommand(connection, queryParameters, -1, -1))
{
command.AddParameters(queryParameters);
var count = command.GetRecordsCount();
return(count);
}
}
case TableType.StoredProcedure:
{
using (var command = CreateGetStoredProcedureRecordsCommand(connection, queryParameters, -1, -1))
{
command.AddParameters(queryParameters);
var count = command.GetRecordsCount();
return(count);
}
}
case TableType.Sql:
{
using (var command = connection.CreateCommand(source.Table))
{
command.AddParameters(queryParameters);
var count = command.GetRecordsCount();
return(count);
}
}
default:
{
return(0);
}
}
}
}
public SqlTableReader(DatabaseSource source, int offset = 0, int fetchCount = 0, DataSourceParameters parameters = null)
: base(source.ToString(), offset, fetchCount)
{
Argument.IsNotNull(() => source);
_databaseSource = source;
_totalRecordCount = 0;
QueryParameters = parameters;
}
public void Process(string fileFullName)
{
string fileName = Path.GetFileName(fileFullName);
//move file
string moveTo = Path.Combine(LocalFileSystemFolderArchive, fileName);
Directory.CreateDirectory(Path.GetDirectoryName(moveTo));
string renamedToIdentifier = Guid.NewGuid().ToString();
if (File.Exists(moveTo))
{
string moveToBUName = Path.Combine(LocalFileSystemFolderArchive, string.Format("{0}_{1}", renamedToIdentifier, fileName));
new FileUtility().FileCopy(moveTo, moveToBUName, true); //backup existing
}
new FileUtility().FileCopy(fileFullName, moveTo, true); //move file
if (this.DataSourceParameters == null)
{
this.DataSourceParameters = new Dictionary <string, object>();
}
DataSourceParameters.Clear();
DataSourceParameters.Add("DataSourceId", this.DataSourceId);
FileSystemWatcherEventArgs e = new FileSystemWatcherEventArgs(DataSourceParameters, moveTo, renamedToIdentifier);
try
{
//if (File.Exists(moveTo))
//{
// using (StreamReader sr = new StreamReader(moveTo))
// {
// e.FileContent = sr.ReadToEnd();
// sr.Close();
// }
// InvokeFileDownloaded(e);
//}
InvokeFileDownloaded(e);
}
catch (BusinessException ex)
{
ExtensionMethods.TraceError(ex.ToString());
Trace.Flush();
}
catch (Exception ex)
{
ExtensionMethods.TraceError("An unknown error occurred!. {0}. {1} This error needs immediate attention",
ex.ToString(), Environment.NewLine + Environment.NewLine);
Trace.Flush();
}
}
public ActionResult DeleteBulk(long[] ids, string UrlReferrer)
{
foreach (var id in ids.Where(p => p > 0))
{
DataSourceParameters datasourceparameters = db.DataSourceParameterss.Find(id);
db.Entry(datasourceparameters).State = EntityState.Deleted;
db.DataSourceParameterss.Remove(datasourceparameters);
try
{
db.SaveChanges();
}
catch { }
}
return(Json("Success", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
public override DbDataReader GetRecords(DataSourceParameters queryParameters = null, int offset = 0, int fetchCount = -1)
{
#pragma warning disable IDISP001 // Dispose created.
var connection = GetOpenedConnection();
#pragma warning restore IDISP001 // Dispose created.
var source = Source;
var isPagingQuery = offset >= 0 && fetchCount > 0;
var sql = source.Table;
DbCommand command;
switch (source.TableType)
{
case TableType.Table:
command = CreateGetTableRecordsCommand(connection, queryParameters, offset, fetchCount);
break;
case TableType.View:
command = CreateGetViewRecordsCommand(connection, queryParameters, offset, fetchCount);
break;
case TableType.StoredProcedure:
command = CreateGetStoredProcedureRecordsCommand(connection, queryParameters, offset, fetchCount);
break;
case TableType.Function:
command = CreateGetFunctionRecordsCommand(connection, queryParameters, offset, fetchCount);
break;
case TableType.Sql:
command = connection.CreateCommand(sql);
break;
default:
throw new NotSupportedException($"'{source.TableType}' not supported");
}
command.AddParameters(queryParameters);
var reader = command.ExecuteReader();
if (isPagingQuery && (source.TableType == TableType.Sql || source.TableType == TableType.StoredProcedure || source.TableType == TableType.Function))
{
return(new SkipTakeDbReader(reader, offset, fetchCount));
}
return(reader);
}
protected Task <ItemResult <TDto> > SaveImplementation(TDto dto, DataSourceParameters parameters, IDataSource <T> dataSource, IBehaviors <T> behaviors)
{
var kind = behaviors.DetermineSaveKind(dto).Kind;
if (kind == SaveKind.Create && !GeneratedForClassViewModel.SecurityInfo.IsCreateAllowed(User))
{
Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return(Task.FromResult <ItemResult <TDto> >($"Creation of {GeneratedForClassViewModel.DisplayName} items not allowed."));
}
if (kind == SaveKind.Update && !GeneratedForClassViewModel.SecurityInfo.IsEditAllowed(User))
{
Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return(Task.FromResult <ItemResult <TDto> >($"Editing of {GeneratedForClassViewModel.DisplayName} items not allowed."));
}
return(behaviors.SaveAsync(dto, dataSource, parameters));
}
//private List<SreKey> Keys
//{
// get
// {
// List<SreKey> keys = Cache.Instance.Bag[DataSourceId + ".keys"] as List<SreKey>;
// if (keys == null)
// {
// keys = new Manager().GetApplicationKeys(DataSourceId, true);
// Cache.Instance.Bag.Add(DataSourceId + ".keys", keys);
// }
// return keys;
// }
//}
#endregion Properties
/// <summary>
/// Keeps pulling from database (MS SQL, MS SQL CE, Oracle)
/// </summary>
/// <param name="dataSource">The data source object</param>
public SqlWatcher(SreDataSource dataSource)
{
this.DataSource = new DataSource(dataSource.Id, string.Empty);
//DataSourceName = dataSource.Name;
ProcessingBy = dataSource.ProcessingBy;
if (string.IsNullOrEmpty(ProcessingBy))
{
ProcessingBy = dataSource.Name;
}
string strinterval = DataSource.Keys.GetKeyValue(SreKeyTypes.SqlWatchInterval);
int interval = 0;
int.TryParse(strinterval, out interval);
if (interval <= 0)
{
interval = 2;
}
this.Interval = interval;
string appPullFolder = SreConfigurationSection.CurrentConfig.LocalFileWatcher.DirectoryPull + "\\" + dataSource.Id;
string appOutputFolder = SreConfigurationSection.CurrentConfig.LocalFileWatcher.DirectoryOutput + "\\" + dataSource.Id + "\\" + DateTime.Now.ToString("yyyyMMdd");
this.DataSourceParameters = new Dictionary <string, object>();
DataSourceParameters.Add("DataSourceId", dataSource.Id);
DataSourceParameters.Add("PullFolder", appPullFolder);
DataSourceParameters.Add("OutputFolder", appOutputFolder);
DataSourceParameters.Add("ProcessingBy", dataSource.ProcessingBy);
this.ReturnType = DataSource.Keys.GetKeyValue(SreKeyTypes.PullSqlReturnType);
if (this.ReturnType == "I")
{
this.InterfaceName = DataSource.Keys.GetKeyValue(SreKeyTypes.PullSqlInterfaceName);
if ((!string.IsNullOrEmpty(this.InterfaceName)) &&
(Type.GetType(this.InterfaceName) != null))
{
object objInputFileGenerator = Activator.CreateInstance(Type.GetType(this.InterfaceName), this);
this.InputFileGenerator = (InputFileGenerator)objInputFileGenerator;
}
}
}
public ActionResult BulkAssociate(long[] ids, string AssociatedType, string HostingEntity, string HostingEntityID)
{
var HostingID = Convert.ToInt64(HostingEntityID);
if (HostingID == 0)
{
return(Json("Error", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
if (HostingEntity == "EntityDataSource" && AssociatedType == "EntityDataSourceParameters")
{
foreach (var id in ids.Where(p => p > 0))
{
DataSourceParameters obj = db.DataSourceParameterss.Find(id);
db.Entry(obj).State = EntityState.Modified;
obj.EntityDataSourceParametersID = HostingID;
db.SaveChanges();
}
}
return(Json("Success", "application/json", System.Text.Encoding.UTF8, JsonRequestBehavior.AllowGet));
}
protected DataSourceParameters GetArgs(string query)
{
using (var connection = GetOpenedConnection())
{
var queryParameters = new DataSourceParameters();
using var reader = connection.GetReader(query);
while (reader.Read())
{
var args = new DataSourceParameter
{
Name = reader.GetValue(0)?.ToString(),
Type = reader.GetValue(1)?.ToString()
};
queryParameters.Parameters.Add(args);
}
return(queryParameters);
}
}
public ActionResult CreateWizard([Bind(Include = "Id,ConcurrencyKey,ArgumentName,ArgumentValue,HostingEntity,flag,other,EntityDataSourceParametersID")] DataSourceParameters datasourceparameters, string UrlReferrer)
{
CheckBeforeSave(datasourceparameters);
if (ModelState.IsValid)
{
db.DataSourceParameterss.Add(datasourceparameters);
db.SaveChanges();
if (!string.IsNullOrEmpty(UrlReferrer))
{
return(Redirect(UrlReferrer));
}
else
{
return(RedirectToAction("Index"));
}
}
LoadViewDataAfterOnCreate(datasourceparameters);
return(View(datasourceparameters));
}
// GET: /DataSourceParameters/Details/5
public ActionResult Details(int?id, string HostingEntityName, string AssociatedType)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DataSourceParameters datasourceparameters = db.DataSourceParameterss.Find(id);
if (datasourceparameters == null)
{
return(HttpNotFound());
}
ViewData["AssociatedType"] = AssociatedType;
ViewData["HostingEntityName"] = HostingEntityName;
LoadViewDataBeforeOnEdit(datasourceparameters);
if (!string.IsNullOrEmpty(AssociatedType))
{
LoadViewDataForCount(datasourceparameters, AssociatedType);
}
return(View(datasourceparameters));
}
// GET: /DataSourceParameters/Delete/5
public ActionResult Delete(int id)
{
if (!User.CanDelete("DataSourceParameters"))
{
return(RedirectToAction("Index", "Error"));
}
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DataSourceParameters datasourceparameters = db.DataSourceParameterss.Find(id);
if (datasourceparameters == null)
{
throw(new Exception("Deleted"));
}
if (ViewData["DataSourceParametersParentUrl"] == null && Request.UrlReferrer != null && !Request.UrlReferrer.AbsolutePath.EndsWith("/DataSourceParameters"))
{
ViewData["DataSourceParametersParentUrl"] = Request.UrlReferrer;
}
return(View(datasourceparameters));
}
public virtual Task <ItemResult <SmsMessageDtoGen> > Save(
SmsMessageDtoGen dto,
[FromQuery] DataSourceParameters parameters,
IDataSource <SendGridDemo.Data.Models.SmsMessage> dataSource,
IBehaviors <SendGridDemo.Data.Models.SmsMessage> behaviors)
=> SaveImplementation(dto, parameters, dataSource, behaviors);
public virtual Task <ItemResult <SmsMessageDtoGen> > Get(
int id,
DataSourceParameters parameters,
IDataSource <SendGridDemo.Data.Models.SmsMessage> dataSource)
=> GetImplementation(id, parameters, dataSource);
public virtual Task <ItemResult <ThingDtoGen> > Save(
ThingDtoGen dto,
[FromQuery] DataSourceParameters parameters,
IDataSource <MarsError.Data.Models.Thing> dataSource,
IBehaviors <MarsError.Data.Models.Thing> behaviors)
=> SaveImplementation(dto, parameters, dataSource, behaviors);
public virtual Task <ItemResult <ThingDtoGen> > Get(
long id,
DataSourceParameters parameters,
IDataSource <MarsError.Data.Models.Thing> dataSource)
=> GetImplementation(id, parameters, dataSource);
public virtual Task <ItemResult <TalkGroupDtoGen> > Save(
TalkGroupDtoGen dto,
[FromQuery] DataSourceParameters parameters,
IDataSource <MMDash.Data.Models.TalkGroup> dataSource,
IBehaviors <MMDash.Data.Models.TalkGroup> behaviors)
=> SaveImplementation(dto, parameters, dataSource, behaviors);
public virtual Task <ItemResult <TalkGroupDtoGen> > Get(
int id,
DataSourceParameters parameters,
IDataSource <MMDash.Data.Models.TalkGroup> dataSource)
=> GetImplementation(id, parameters, dataSource);
public virtual Task <ItemResult <CaseProductDtoGen> > Save(
CaseProductDtoGen dto,
[FromQuery] DataSourceParameters parameters,
IDataSource <Coalesce.Domain.CaseProduct> dataSource,
IBehaviors <Coalesce.Domain.CaseProduct> behaviors)
=> SaveImplementation(dto, parameters, dataSource, behaviors);
public virtual Task <ItemResult <CaseProductDtoGen> > Get(
int id,
DataSourceParameters parameters,
IDataSource <Coalesce.Domain.CaseProduct> dataSource)
=> GetImplementation(id, parameters, dataSource);
public SqlTableReader(string source, int offset = 0, int fetchCount = 0, DataSourceParameters parameters = null)
: this(new DatabaseSource(source), offset, fetchCount, parameters)
{
}
