// GET api/summary/GetList
public IEnumerable <QuestionDataModel> GetList(string value, string value1)
{
var settingCategory = value1;
var searchString = value;
var dictionaryObject = JsonConvert.DeserializeObject <Dictionary <string, string> >(searchString);
// save search filter parameters in user preference
if (dictionaryObject != null)
{
foreach (var searchFilterColumnName in dictionaryObject.Keys)
{
var searchFilterValue = dictionaryObject[searchFilterColumnName];
PerferenceUtility.UpdateUserPreference(settingCategory, searchFilterColumnName, dictionaryObject[searchFilterColumnName]);
}
}
var dataQuery = new QuestionDataModel();
try
{
dataQuery = JsonConvert.DeserializeObject <QuestionDataModel>(searchString);
}
catch { }
// igonore when value is -1
if (dataQuery.QuestionCategoryId == -1)
{
dataQuery.QuestionCategoryId = null;
}
return(QuestionDataManager.GetEntityDetails(dataQuery, SessionVariables.RequestProfile));
}
public void LoadData(int questionId, bool showId)
{
Clear();
var data = new QuestionDataModel();
data.QuestionId = questionId;
var items = QuestionDataManager.GetEntityDetails(data, SessionVariables.RequestProfile);
if (items.Count != 1)
{
return;
}
var item = items[0];
QuestionId = item.QuestionId;
Question = item.QuestionPhrase;
Category = item.QuestionCategoryId;
SortOrder = item.SortOrder;
if (!showId)
{
txtQuestionId.Text = item.QuestionId.ToString();
oHistoryList.Setup(PrimaryEntity, questionId, PrimaryEntityKey);
}
else
{
txtQuestionId.Text = String.Empty;
}
oUpdateInfo.LoadText(item.UpdatedDate, item.UpdatedBy, item.LastAction);
}
private string UpdateQuestion(object data, int questionID, int surveyID)
{
QuestionDataModel question = jsonHelper.FromJson <QuestionDataModel>(data.ToString());
if (!string.IsNullOrEmpty(jsonHelper.ErrorMessage))
{
return(jsonHelper.ErrorMessage);
}
string result = "Entered survey not found, failed to update question";
List <SurveyDataModel> existingSurveys = surveyService.GetSurveys();
if (existingSurveys != null)
{
if (existingSurveys.Exists(o => o.SurveyID == question.SurveyID))
{
if (surveyQuestionService.UpdateQuestion(question))
{
result = "Successfully updated question";
}
else
{
result = "Error - No changes made";
}
}
}
return(result);
}
private static string Save(QuestionDataModel data, RequestProfile requestProfile, string action)
{
var sql = "EXEC ";
switch (action)
{
case "Create":
sql += "dbo.QuestionInsert " + "\r\n" +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId) +
", " + ToSQLParameter(BaseDataModel.BaseDataColumns.ApplicationId, requestProfile.ApplicationId);
break;
case "Update":
sql += "dbo.QuestionUpdate " + "\r\n" +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId);
break;
default:
break;
}
sql = sql + ", " + ToSQLParameter(data, QuestionDataModel.DataColumns.QuestionId) +
", " + ToSQLParameter(data, QuestionDataModel.DataColumns.QuestionPhrase) +
", " + ToSQLParameter(data, QuestionDataModel.DataColumns.QuestionCategoryId) +
", " + ToSQLParameter(data, QuestionDataModel.DataColumns.SortOrder);
return(sql);
}
public override int?Save(string action)
{
var data = new QuestionDataModel();
data.QuestionId = QuestionId;
data.QuestionPhrase = Question;
data.QuestionCategoryId = Category;
data.SortOrder = SortOrder;
if (action == "Insert")
{
var dtQuestion = QuestionDataManager.DoesExist(data, SessionVariables.RequestProfile);
if (dtQuestion.Rows.Count == 0)
{
QuestionDataManager.Create(data, SessionVariables.RequestProfile);
}
else
{
throw new Exception("Record with given ID already exists.");
}
}
else
{
QuestionDataManager.Update(data, SessionVariables.RequestProfile);
}
return(QuestionId);
}
protected override void ShowData(int questionId)
{
base.ShowData(questionId);
oDetailButtonPanel.SetId = SetId;
Clear();
var data = new QuestionDataModel();
data.QuestionId = questionId;
var items = QuestionDataManager.GetEntityDetails(data, SessionVariables.RequestProfile);
if (items.Count == 1)
{
var item = items[0];
lblQuestionId.Text = item.QuestionId.ToString();
lblQuestion.Text = item.QuestionPhrase;
lblCategory.Text = item.QuestionCategory;
lblSortOrder.Text = item.SortOrder.ToString();
oUpdateInfo.LoadText(item.UpdatedDate, item.UpdatedBy, item.LastAction);
oHistoryList.Setup(PrimaryEntity, questionId, "Question");
}
}
protected override DataTable UpdateData()
{
var UpdatedData = new DataTable();
var data = new QuestionDataModel();
UpdatedData = QuestionDataManager.Search(data, SessionVariables.RequestProfile).Clone();
for (var i = 0; i < SelectedData.Rows.Count; i++)
{
data.QuestionId =
Convert.ToInt32(SelectedData.Rows[i][QuestionDataModel.DataColumns.QuestionId].ToString());
data.QuestionPhrase = SelectedData.Rows[i][QuestionDataModel.DataColumns.QuestionPhrase].ToString();
data.QuestionCategoryId = Convert.ToInt32(SelectedData.Rows[i][QuestionDataModel.DataColumns.QuestionCategoryId].ToString());
data.SortOrder =
!string.IsNullOrEmpty(CheckAndGetRepeaterTextBoxValue(QuestionDataModel.DataColumns.SortOrder))
? int.Parse(CheckAndGetRepeaterTextBoxValue(QuestionDataModel.DataColumns.SortOrder).ToString())
: int.Parse(SelectedData.Rows[i][QuestionDataModel.DataColumns.SortOrder].ToString());
QuestionDataManager.Update(data, SessionVariables.RequestProfile);
data = new QuestionDataModel();
data.QuestionId = Convert.ToInt32(SelectedData.Rows[i][QuestionDataModel.DataColumns.QuestionId].ToString());
var dt = QuestionDataManager.Search(data, SessionVariables.RequestProfile);
if (dt.Rows.Count == 1)
{
UpdatedData.ImportRow(dt.Rows[0]);
}
}
return(UpdatedData);
}
private string AddNewQuestion(object data)
{
string result = "Entered survey not found, failed to add question";
QuestionDataModel question = jsonHelper.FromJson <QuestionDataModel>(data);
if (!string.IsNullOrEmpty(jsonHelper.ErrorMessage))
{
return(jsonHelper.ErrorMessage);
}
List <SurveyDataModel> existingSurveys = surveyService.GetSurveys();
if (existingSurveys != null)
{
if (existingSurveys.Exists(o => o.SurveyID == question.SurveyID))
{
if (surveyQuestionService.AddNewQuestion(question))
{
result = "Successfully added new question";
}
else
{
result = "Error - Failed to add new question";
}
}
}
return(result);
}
public static DataTable Search(QuestionDataModel data, RequestProfile requestProfile)
{
var list = GetEntityDetails(data, requestProfile, 0);
var table = list.ToDataTable();
return(table);
}
private System.Data.DataTable GetData()
{
var data = new QuestionDataModel();
var dt = QuestionDataManager.Search(data, SessionVariables.RequestProfile);
return(dt);
}
private DataTable GetAssociatedQuestionCategorys(int questionId)
{
QuestionDataModel data = new QuestionDataModel();
data.QuestionId = questionId;
var dt = QuestionDataManager.GetDetails(data, SessionVariables.RequestProfile);
return(dt);
}
public static DataTable DoesExist(QuestionDataModel data, RequestProfile requestProfile)
{
var doesExistRequest = new QuestionDataModel();
doesExistRequest.QuestionId = data.QuestionId;
doesExistRequest.QuestionPhrase = data.QuestionPhrase;
return(Search(doesExistRequest, requestProfile));
}
protected override DataTable GetEntityData(int?entityKey)
{
var questiondata = new QuestionDataModel();
questiondata.QuestionId = entityKey;
var results = QuestionDataManager.Search(questiondata, SessionVariables.RequestProfile);
return(results);
}
protected override void Update(Dictionary <string, string> values)
{
var data = new QuestionDataModel();
// copies properties from values dictionary object to data object
PropertyMapper.CopyProperties(data, values);
QuestionDataManager.Update(data, SessionVariables.RequestProfile);
base.Update(values);
}
static public DataSet DeleteChildren(QuestionDataModel data, RequestProfile requestProfile)
{
var sql = "EXEC dbo.QuestionChildrenDelete " +
" " + ToSQLParameter(BaseDataModel.BaseDataColumns.AuditId, requestProfile.AuditId) +
", " + ToSQLParameter(data, QuestionDataModel.DataColumns.QuestionId);
var oDT = new DBDataSet("Delete Children", sql, DataStoreKey);
return(oDT.DBDataset);
}
public static bool DoesExist(QuestionDataModel data, RequestProfile requestProfile)
{
var doesExistRequest = new QuestionDataModel();
doesExistRequest.QuestionId = data.QuestionId;
doesExistRequest.QuestionPhrase = data.QuestionPhrase;
var list = GetEntityDetails(doesExistRequest, requestProfile, 0);
return(list.Count > 0);
}
protected override void Clear()
{
base.Clear();
var data = new QuestionDataModel();
QuestionId = data.QuestionId;
Question = data.QuestionPhrase;
Category = data.QuestionCategoryId;
SortOrder = data.SortOrder;
}
private void UpdateData(ArrayList values)
{
var data = new QuestionDataModel();
data.QuestionId = int.Parse(values[0].ToString());
data.QuestionPhrase = values[1].ToString();
data.QuestionCategoryId = int.Parse(values[2].ToString());
data.SortOrder = int.Parse(values[3].ToString());
QuestionDataManager.Update(data, SessionVariables.RequestProfile);
ReBindEditableGrid();
}
public static string ToSQLParameter(QuestionDataModel data, string dataColumnName)
{
var returnValue = "NULL";
switch (dataColumnName)
{
case QuestionDataModel.DataColumns.QuestionId:
if (data.QuestionId != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NUMBER, QuestionDataModel.DataColumns.QuestionId, data.QuestionId);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, QuestionDataModel.DataColumns.QuestionId);
}
break;
case QuestionDataModel.DataColumns.QuestionPhrase:
if (!string.IsNullOrEmpty(data.QuestionPhrase))
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, QuestionDataModel.DataColumns.QuestionPhrase, data.QuestionPhrase);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, QuestionDataModel.DataColumns.QuestionPhrase);
}
break;
case QuestionDataModel.DataColumns.QuestionCategoryId:
if (data.QuestionCategoryId != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_STRING_OR_DATE, QuestionDataModel.DataColumns.QuestionCategoryId, data.QuestionCategoryId);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, QuestionDataModel.DataColumns.QuestionCategoryId);
}
break;
case QuestionDataModel.DataColumns.SortOrder:
if (data.SortOrder != null)
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NUMBER, QuestionDataModel.DataColumns.SortOrder, data.SortOrder);
}
else
{
returnValue = string.Format(SQL_TEMPLATE_PARAMETER_NULL, QuestionDataModel.DataColumns.SortOrder);
}
break;
}
return(returnValue);
}
public async Task <ActionResult> Edit(int id, IFormCollection collection)
{
var question = new QuestionDataModel(int.Parse(collection["QuestionNumber"]), int.Parse(collection["surveyID"]), collection["Question"],
collection["Type"], collection["Options"]);
api.Client().BaseAddress = new Uri(baseAddress);
HttpResponseMessage response = await api.Client().PutAsJsonAsync("api/surveyQuestions/" + int.Parse(collection["QuestionNumber"]) + "/"
+ collection["surveyID"], question);
response.EnsureSuccessStatusCode();
return(RedirectToAction("Index", "Questions"));
}
protected void btnDelete_Click(object sender, EventArgs e)
{
try
{
var notDeletableIds = new List <int>();
var deleteIndexList = DeleteIds.Split(',');
foreach (var index in deleteIndexList)
{
var data = new QuestionDataModel();
data.QuestionId = int.Parse(index);
if (!QuestionDataManager.IsDeletable(data, SessionVariables.RequestProfile))
{
notDeletableIds.Add((int)(data.QuestionId));
}
}
if (notDeletableIds.Count == 0)
{
foreach (var index in deleteIndexList)
{
var data = new QuestionDataModel();
data.QuestionId = int.Parse(index);
QuestionDataManager.Delete(data, SessionVariables.RequestProfile);
}
DeleteAndRedirect();
}
else
{
var msg = String.Empty;
foreach (var id in notDeletableIds)
{
if (!string.IsNullOrEmpty(msg))
{
msg += ", <br/>";
}
msg += "QuestionId: " + id + " has detail records";
}
Response.Write(msg);
}
}
catch (Exception ex)
{
Response.Write(ex.Message);
}
}
public HttpResponseMessage PostQuestion([FromBody] QuestionDataModel model)
{
var rez = _questionDal.AddQueston(model.Text, model.DifficultyID, model.SubjectId, model.TypeId);
foreach (var answer in model.Answers)
{
if (String.IsNullOrEmpty(answer.Text))
{
continue;
}
_answerDal.AddAnswer(answer.Text, answer.Value, rez.Id);
}
return(Request.CreateResponse(HttpStatusCode.Created, new { Message = "Question has been created" }));
}
private DataTable GetQuestionData(int questionCategoryId)
{
var data = new QuestionDataModel();
data.QuestionCategoryId = questionCategoryId;
var dt = QuestionDataManager.Search(data, SessionVariables.RequestProfile);
var fdt = QuestionDataManager.GetList(SessionVariables.RequestProfile);
var resultdt = fdt.Clone();
foreach (DataRow row in dt.Rows)
{
var rows = fdt.Select(QuestionDataModel.DataColumns.QuestionId + " = " + row[QuestionDataModel.DataColumns.QuestionId]);
resultdt.ImportRow(rows[0]);
}
return(resultdt);
}
public static void Delete(QuestionDataModel dataQuery, RequestProfile requestProfile)
{
const string sql = @"dbo.QuestionDelete ";
var parameters =
new
{
AuditId = requestProfile.AuditId
,
QuestionId = dataQuery.QuestionId
};
using (var dataAccess = new DataAccessBase(DataStoreKey))
{
dataAccess.Connection.Execute(sql, parameters, commandType: CommandType.StoredProcedure);
}
}
public static bool IsDeletable(QuestionDataModel data, RequestProfile requestProfile)
{
var isDeletable = true;
var ds = GetChildren(data, requestProfile);
if (ds != null && ds.Tables.Count > 0)
{
foreach (DataTable dt in ds.Tables)
{
if (dt.Rows.Count > 0)
{
isDeletable = false;
break;
}
}
}
return(isDeletable);
}
public bool UpdateQuestion(QuestionDataModel question)
{
bool result = false;
if (question != null)
{
string SqlQuery = "UPDATE Questions SET Question = @Question, Type = @Type, Options = @Options WHERE SurveyID = @SurveyID AND QuestionNumber = @QuestionNumber";
try
{
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = CONNECTION_STRING;
conn.Open();
SqlCommand command = new SqlCommand(SqlQuery, conn);
if (SqlQuery.Length > 0)
{
command = new SqlCommand(SqlQuery, conn);
command.Parameters.AddWithValue("@SurveyID", question.SurveyID);
command.Parameters.AddWithValue("@QuestionNumber", question.QuestionNumber);
command.Parameters.AddWithValue("@Question", question.Question = question.Question ?? "");
command.Parameters.AddWithValue("@Type", question.Type = question.Type ?? "");
command.Parameters.AddWithValue("@Options", question.Options = question.Options ?? "");
}
int sqlResult = command.ExecuteNonQuery();
result = sqlResult < 0 ? false : true;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception Caught - " + ex.Message);
}
}
if (!result)
{
System.Diagnostics.Debug.WriteLine("Error - record not updated in database");
}
return(result);
}
public bool AddNewQuestion(QuestionDataModel question)
{
bool result = false;
if (question != null)
{
string SqlQuery = "INSERT INTO Questions (SurveyID, QuestionNumber, Question, Type, Options) VALUES (@SurveyID, @QuestionNumber, @Question, @Type, @Options)";
try
{
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = CONNECTION_STRING;
conn.Open();
SqlCommand command = new SqlCommand(SqlQuery, conn);
if (SqlQuery.Length > 0)
{
command = new SqlCommand(SqlQuery, conn);
command.Parameters.AddWithValue("@SurveyID", question.SurveyID);
command.Parameters.AddWithValue("@QuestionNumber", question.QuestionNumber);
command.Parameters.AddWithValue("@Question", question.Question = question.Question ?? "");
command.Parameters.AddWithValue("@Type", question.Type = question.Type ?? "");
command.Parameters.AddWithValue("@Options", question.Options = question.Options ?? "");
}
int sqlResult = command.ExecuteNonQuery();
result = sqlResult < 0 ? false : true;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception Caught - " + ex.Message);
}
}
if (!result)
{
System.Diagnostics.Debug.WriteLine("Error - record not saved to database");
}
return(result);
}
protected override DataTable GetData()
{
try
{
SuperKey = ApplicationCommon.GetSuperKey();
SetId = ApplicationCommon.GetSetId();
var selectedrows = new DataTable();
var questiondata = new QuestionDataModel();
selectedrows = QuestionDataManager.GetDetails(questiondata, SessionVariables.RequestProfile).Clone();
if (!string.IsNullOrEmpty(SuperKey))
{
var systemEntityTypeId = (int)PrimaryEntity;
var lstEntityKeys = ApplicationCommon.GetSuperKeyDetails(systemEntityTypeId, SuperKey);
foreach (var entityKey in lstEntityKeys)
{
questiondata.QuestionId = entityKey;
var result = QuestionDataManager.GetDetails(questiondata, SessionVariables.RequestProfile);
selectedrows.ImportRow(result.Rows[0]);
}
}
else
{
questiondata.QuestionId = SetId;
var result = QuestionDataManager.GetDetails(questiondata, SessionVariables.RequestProfile);
selectedrows.ImportRow(result.Rows[0]);
}
return(selectedrows);
}
catch (Exception ex)
{
Response.Write(ex.Message);
}
return(null);
}
public async Task <ActionResult> Create(IFormCollection collection)
{
/*
* try
* {
* // TODO: Add insert logic here
*
* return RedirectToAction(nameof(Index));
* }
* catch
* {
* return View();
* }
*/
string question = collection["Question"];
int surveyID = int.Parse(collection["surveyID"]);
string type = collection["Type"];
string options = collection["Options"];
api.Client().BaseAddress = new Uri(baseAddress);
requestUri = "api/SurveyQuestions";
var responseSurveyQuestions = api.GetResponseAsync(baseAddress, requestUri);
var list = JsonConvert.DeserializeObject <List <QuestionDataModel> >(responseSurveyQuestions.Result.Content.ReadAsAsync <string>().Result);
list = list.Where(x => x.SurveyID == surveyID).ToList();
int questionNumber = list.Count + 1;
var Question = new QuestionDataModel(questionNumber, surveyID, question, type, options);
HttpResponseMessage response = await api.Client().PostAsJsonAsync("api/surveyQuestions/save", Question);
response.EnsureSuccessStatusCode();
return(RedirectToAction("Index", "Questions"));
}
public static List <QuestionDataModel> GetEntityDetails(QuestionDataModel dataQuery, RequestProfile requestProfile, int returnAuditInfo = BaseDataManager.ReturnAuditInfoOnDetails)
{
const string sql = @"dbo.QuestionSearch ";
var parameters =
new
{
AuditId = requestProfile.AuditId
, ApplicationId = requestProfile.ApplicationId
, ReturnAuditInfo = returnAuditInfo
, QuestionCategoryId = dataQuery.QuestionCategoryId
, QuestionPhrase = dataQuery.QuestionPhrase
, QuestionId = dataQuery.QuestionId
};
List <QuestionDataModel> result;
using (var dataAccess = new DataAccessBase(DataStoreKey))
{
result = dataAccess.Connection.Query <QuestionDataModel>(sql, parameters, commandType: CommandType.StoredProcedure).ToList();
}
return(result);
}
