public HttpResponseMessage AddBlog(BlogAddRequest model)
{
try
{
if (ModelState.IsValid)
{
BlogService svc = new BlogService();
int?id = svc.Insert(model);
ItemResponse <int?> resp = new ItemResponse <int?>();
resp.Item = id;
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
internal static void MapCommonParameters(BlogAddRequest model, SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@userIdCreated", UserService.GetCurrentUserId());
paramCollection.AddWithValue("@title", model.Title);
paramCollection.AddWithValue("@body", model.Body);
paramCollection.AddWithValue("@blogCategory", model.BlogCategory);
paramCollection.AddWithValue("@private", model.Private);
DataTable BlogTagIdArray = new DataTable();
BlogTagIdArray.Columns.Add("BlogTagId", typeof(Int32));
if (model.BlogTagIds != null)
{
for (int i = 0; i < model.BlogTagIds.Count; i++)
{
BlogTagIdArray.Rows.Add(model.BlogTagIds[i]);
}
}
SqlParameter BlogTagIdTable = new SqlParameter();
BlogTagIdTable.ParameterName = "@blogTagIds";
BlogTagIdTable.SqlDbType = System.Data.SqlDbType.Structured;
BlogTagIdTable.Value = BlogTagIdArray;
paramCollection.Add(BlogTagIdTable);
}
public void Update(BlogAddRequest model)
{
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
if (conn.State == System.Data.ConnectionState.Open)
{
string sqlCmd = "Blog_Update";
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", model.Id);
cmd.Parameters.AddWithValue("@Title", model.Title);
cmd.Parameters.AddWithValue("@BlogContent", model.BlogContent);
cmd.Parameters.AddWithValue("@ImageUrl", model.ImageUrl);
cmd.Parameters.AddWithValue("@ModifiedBy", model.ModifiedBy);
cmd.ExecuteNonQuery();
}
}
}
}
public ActionResult <ItemResponse <int> > Create(BlogAddRequest model)
{
ObjectResult result = null;
try
{
int userId = _authService.GetCurrentUserId();
int id = _service.Add(model, userId);
ItemResponse <int> response = new ItemResponse <int>()
{
Item = id
};
result = Created201(response);
}
catch (Exception ex)
{
base.Logger.LogError(ex.ToString());
ErrorResponse response = new ErrorResponse(ex.Message);
result = StatusCode(500, response);
}
return(result);
}
public int Add(BlogAddRequest model, int createdById)
{
int id = 0;
string procName = "[dbo].[Blogs_Insert]";
_data.ExecuteNonQuery(procName,
inputParamMapper : delegate(SqlParameterCollection col)
{
MapAddUpdate(col, model);
col.AddWithValue("@authorId", createdById);
SqlParameter idOut = new SqlParameter("@Id", SqlDbType.Int);
idOut.Direction = ParameterDirection.Output;
col.Add(idOut);
},
returnParameters : delegate(SqlParameterCollection returnCol)
{
object oId = returnCol["@Id"].Value;
Int32.TryParse(oId.ToString(), out id);
});
return(id);
}
public int InsertBlog(BlogAddRequest model)
{
int id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Blogs_Insert"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@Title", model.Title);
paramCollection.AddWithValue("@DatePublished", model.PublishedDate);
paramCollection.AddWithValue("@BlogPost", model.BlogPost);
paramCollection.AddWithValue("@Tags", model.Tags);
paramCollection.AddWithValue("@IsFeatured", model.IsFeatured);
SqlParameter p = new SqlParameter("@Id", System.Data.SqlDbType.Int);
p.Direction = System.Data.ParameterDirection.Output;
paramCollection.Add(p);
},
returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@Id"].Value.ToString(), out id);
}
);
return(id);
}
public int Insert(BlogAddRequest model)
{
int id = 0;
string connectiongString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connectiongString))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "dbo.blog_insert";
SqlParameterCollection paramCollection = cmd.Parameters;
BlogService.MapCommonParameters(model, paramCollection);
SqlParameter p = new SqlParameter("@id", SqlDbType.Int);
p.Direction = ParameterDirection.Output;
paramCollection.Add(p);
cmd.ExecuteNonQuery();
id = Convert.ToInt32(paramCollection["@id"].Value);
}
}
return(id);
}
public ActionResult <ItemResponse <Blog> > Add(BlogAddRequest model)
{
int iCode = 200;
BaseResponse response;
try
{
int createdById = _authenticationService.GetCurrentUserId();
UserVeteranBase user = _authenticationService.GetCurrentUser();
int id = _blogService.Add(model, createdById);
response = new ItemResponse <int>()
{
Item = id
};
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
iCode = 500;
response = new ErrorResponse($"Generic Exception: {ex.Message}");
}
return(StatusCode(iCode, response));
}
public int Insert(BlogAddRequest model, int userId)
{
int blogId = 0;
if (model == null)
{
throw new ArgumentNullException("A parameter model is required");
}
string storedProc = "[dbo].[Blogs_Insert]";
_dataProvider.ExecuteNonQuery(storedProc
, delegate(SqlParameterCollection sqlParams)
{
MapParameters(model, sqlParams);
sqlParams.AddWithValue("@UserId", userId);
SqlParameter idParameter = new SqlParameter("@Id", System.Data.SqlDbType.Int);
idParameter.Direction = System.Data.ParameterDirection.Output;
sqlParams.Add(idParameter);
}
, returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@Id"].Value.ToString(), out blogId);
}
///////////////////
////////////////////////
);
return(blogId);
}
private static void AddCommonParams(BlogAddRequest model, SqlParameterCollection col)
{
col.AddWithValue("@BlogTypeId", model.BlogTypeId);
col.AddWithValue("@Title", model.Title);
col.AddWithValue("@Subject", model.Subject);
col.AddWithValue("@Content", model.Content);
col.AddWithValue("@IsPublished", model.IsPublished);
col.AddWithValue("@ImageUrl", model.ImageUrl);
col.AddWithValue("@DatePublish", model.DatePublish);
}
private static void MapAddUpdate(SqlParameterCollection paramCollection, BlogAddRequest requestModel)
{
paramCollection.AddWithValue("@blogTypeId", requestModel.BlogTypeId);
paramCollection.AddWithValue("@title", requestModel.Title);
paramCollection.AddWithValue("@subject", requestModel.Subject);
paramCollection.AddWithValue("@content", requestModel.Content);
paramCollection.AddWithValue("@isPublished", requestModel.IsPublished);
paramCollection.AddWithValue("@imageUrl", requestModel.ImageUrl);
paramCollection.AddWithValue("@datePublish", requestModel.DatePublish);
}
private static void MapParameters(BlogAddRequest model, SqlParameterCollection sqlParams)
{
sqlParams.AddWithValue("@Title", model.Title);
sqlParams.AddWithValue("@Author", model.Author);
sqlParams.AddWithValue("@Body", model.Body);
sqlParams.AddWithValue("@Tags", model.Tags);
sqlParams.AddWithValue("@DateToPublish", model.DateToPublish);
sqlParams.AddWithValue("@StatusId", model.StatusId);
sqlParams.AddWithValue("@Slug", model.Slug);
sqlParams.AddWithValue("@PhotoUrl", model.PhotoUrl);
}
public HttpResponseMessage Create(BlogAddRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
response.Item = _blogService.Insert(model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public IHttpActionResult Post(BlogAddRequest model)
{
try
{
ItemResponse <int> response = new ItemResponse <int>
{
Item = _blogService.Insert(model),
IsSuccessful = true
};
return(Ok(response));
}
catch (Exception ex) { return(BadRequest(ex.Message)); }
}
public HttpResponseMessage Add(BlogAddRequest model)
{
int userId = _auth.GetCurrentUserId();
if (!ModelState.IsValid)
{
return(CreateErrorResponse());
}
int id = _service.Insert(model, userId);
ItemResponse <int> resp = new ItemResponse <int>();
resp.Item = id;
return(Request.CreateResponse(HttpStatusCode.Created, resp));
}
public HttpResponseMessage AddBlog(BlogAddRequest model)
{
// if the Model does not pass validation, there will be an Error response returned with errors
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
//string userId = UserService.GetCurrentUserId();
response.Item = _blogService.InsertBlog(model);
return(Request.CreateResponse(response));
}
public int Insert(BlogAddRequest model)
{
int id = 0;
Adapter.ExecuteQuery("Blogs_Insert", new[] {
SqlDbParameter.Instance.BuildParameter("@UserBaseId", model.UserBaseId, System.Data.SqlDbType.Int),
SqlDbParameter.Instance.BuildParameter("@Name", model.Name, System.Data.SqlDbType.NVarChar),
SqlDbParameter.Instance.BuildParameter("@Body", model.Body, System.Data.SqlDbType.NVarChar),
SqlDbParameter.Instance.BuildParameter("@Image", model.Image, System.Data.SqlDbType.NVarChar),
SqlDbParameter.Instance.BuildParameter("@IsPublic", model.IsPublic, System.Data.SqlDbType.Bit),
SqlDbParameter.Instance.BuildParameter("@Id", id, System.Data.SqlDbType.Int, 0, ParameterDirection.Output)
}, (parameters =>
{
id = parameters.GetParmValue <int>("@Id"); //for inserts
}));
return(id);
}
[HttpPost] // <== the type of Http Methods Supported (Post, Put, Get, Delete) - route already targets api/blogs, why we don't need to put a route
public HttpResponseMessage CreateBlog([FromBody] BlogAddRequest payload)
{
// verify that payload has values in every property
if (string.IsNullOrWhiteSpace(payload.Title) ||
string.IsNullOrWhiteSpace(payload.Content) ||
payload.AuthorId <= 0)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
// Create our response model
ItemResponse <int> response = new ItemResponse <int>();
//string title, string text, string createdUser
response.Item = BlogService.BlogInsert(payload.Title, payload.Content, payload.AuthorId);
return(Request.CreateResponse(response));
} //CreateBlog
public BlogAddRequest GetById(int Id)
{
BlogAddRequest viewModel = new BlogAddRequest();
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
if (conn.State == System.Data.ConnectionState.Open)
{
string sqlCmd = "Blog_SelectById";
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", Id);
SqlDataReader reader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
if (reader.Read())
{
int index = 0;
viewModel.Id = reader.GetInt32(index++);
viewModel.Title = reader.GetString(index++);
viewModel.BlogContent = reader.GetString(index++);
viewModel.ImageUrl = reader.GetString(index++);
viewModel.ModifiedBy = reader.GetString(index++);
return(viewModel);
}
else
{
return(null);
}
}
}
else
{
return(null);
}
}
}
public int Insert(BlogAddRequest model)
{
int id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Blog_Insert",
inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
MapCommonParameters(model, paramCollection);
SqlParameter p = new SqlParameter("@id", SqlDbType.Int);
p.Direction = ParameterDirection.Output;
paramCollection.Add(p);
}, returnParameters : delegate(SqlParameterCollection param)
{
Int32.TryParse(param["@id"].Value.ToString(), out id);
}
);
return(id);
}
public HttpResponseMessage UpdateBlog(BlogAddRequest model)
{
try
{
if (ModelState.IsValid)
{
BlogService svc = new BlogService();
svc.Update(model);
SuccessResponse resp = new SuccessResponse();
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public ActionResult <ItemResponse <int> > Insert(BlogAddRequest request, int userId)
{
ActionResult result = null;
ItemResponse <int> response = null;
try
{
userId = _authService.GetCurrentUserId();
int newId = _blogService.Insert(request, userId);
response = new ItemResponse <int>();
response.Item = newId;
result = Created201(response);
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
result = StatusCode(500, new ErrorResponse(ex.ToString()));
}
return(result);
}
public int Add(BlogAddRequest model, int userId)
{
int Id = 0;
string procName = "[dbo].[Blogs_Insert]";
_data.ExecuteNonQuery(procName, inputParamMapper : delegate(SqlParameterCollection col)
{
col.AddWithValue("@AuthorId", userId);
AddCommonParams(model, col);
SqlParameter idOut = new SqlParameter("@Id", SqlDbType.Int);
idOut.Direction = ParameterDirection.Output;
col.Add(idOut);
}, returnParameters : delegate(SqlParameterCollection returnCollection)
{
object oId = returnCollection["@Id"].Value;
int.TryParse(oId.ToString(), out Id);
});
return(Id);
}
public int?Insert(BlogAddRequest model)
{
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
if (conn.State == System.Data.ConnectionState.Open)
{
string sqlCmd = "Blog_Insert";
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlParameter parm = new SqlParameter();
parm.SqlDbType = System.Data.SqlDbType.Int;
parm.Direction = System.Data.ParameterDirection.Output;
parm.ParameterName = "@Id";
cmd.Parameters.Add(parm);
cmd.Parameters.AddWithValue("@Title", model.Title);
cmd.Parameters.AddWithValue("@BlogContent", model.BlogContent);
cmd.Parameters.AddWithValue("@ImageUrl", model.ImageUrl);
cmd.Parameters.AddWithValue("@ModifiedBy", model.ModifiedBy);
cmd.ExecuteNonQuery();
int id = (int)cmd.Parameters["@Id"].Value;
return(id);
}
}
else
{
return(null);
}
}
}
public List <BlogAddRequest> GetAll()
{
List <BlogAddRequest> result = new List <BlogAddRequest>();
string connStr = System.Configuration.ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
if (conn.State == System.Data.ConnectionState.Open)
{
string sqlCmd = "Blog_GetAll";
using (SqlCommand cmd = new SqlCommand(sqlCmd, conn))
{
cmd.CommandType = System.Data.CommandType.StoredProcedure;
SqlDataReader reader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
while (reader.Read())
{
BlogAddRequest viewModel = new BlogAddRequest();
int index = 0;
viewModel.Id = reader.GetInt32(index++);
viewModel.Title = reader.GetString(index++);
viewModel.BlogContent = reader.GetString(index++);
viewModel.ImageUrl = reader.GetString(index++);
viewModel.ModifiedBy = reader.GetString(index++);
result.Add(viewModel);
}
return(result);
}
}
else
{
return(null);
}
}
}
