/// <summary>
/// Returns the available resources from Data Base
/// </summary>
/// <returns>Resources</returns>
public static ResourcesDTO GetResurces()
{
ResourcesDTO resources = null;
string connectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
string commandText = "SELECT * FROM Resources";
using (var connection = new SqliteConnection(connectionString))
{
connection.Open();
SqliteCommand command = new SqliteCommand(commandText, connection);
using (SqliteDataReader reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
resources = new ResourcesDTO()
{
Water = reader.GetInt32(1),
Coffee = reader.GetInt32(2),
Suger = reader.GetInt32(3)
};
}
}
}
}
return(resources);
}
/// <summary>
/// Get patient with specific resource
/// </summary>
/// <param name="patientID">int</param>
/// <param name="resourcesID">int</param>
/// <returns>Patient DTO</returns>
public async Task <PatientsDTO> GetSpecificResourcesforOnePatient(int patientID, int resourcesID)
{
var patient = await _context.Patient.FindAsync(patientID);
PatientsDTO pDTO = ConvertToDTO(patient);
var patientResources = await _context.PatientResources.Where(x => x.PatientID == patientID)
.Include(x => x.Resources)
.Where(x => x.ResourcesID == resourcesID)
.ToListAsync();
List <ResourcesDTO> patientRes = new List <ResourcesDTO>();
foreach (var pr in patientResources)
{
ResourcesDTO rdto = new ResourcesDTO
{
ResourcesType = pr.Resources.ResourcesType,
Name = pr.Resources.Name,
Description = pr.Resources.Description,
ID = pr.ResourcesID
};
patientRes.Add(rdto);
}
pDTO.Resources = patientRes;
return(pDTO);
}
public ActionResult Edit(string ResourceKey, int acid)
{
LoginUserDetails objLoginUserDetails = (LoginUserDetails)InsiderTrading.Common.Common.GetSessionValue((string)ConstEnum.SessionValue.UserDetails);
ResourcesDTO objResourcesDTO = null;
ResourcesSL objResourcesSL = new ResourcesSL();
try
{
objResourcesDTO = objResourcesSL.GetDetails(objLoginUserDetails.CompanyDBConnectionString, ResourceKey);
ResourceModel objResourceModel = new ResourceModel();
ViewBag.ColumnAlignmentList = FillComboValues(ConstEnum.ComboType.ListOfCode, InsiderTrading.Common.ConstEnum.CodeGroup.ColumnAlignment, null, null, null, null, true);
Common.Common.CopyObjectPropertyByName(objResourcesDTO, objResourceModel);
return(PartialView("~/Views/Resource/Create.cshtml", objResourceModel));
}
catch (Exception exp)
{
string sErrMessage = Common.Common.getResource(exp.InnerException.Data[0].ToString());
ModelState.AddModelError("Error", sErrMessage);
return(RedirectToAction("Index"));
}
finally
{
objLoginUserDetails = null;
objResourcesDTO = null;
objResourcesSL = null;
}
}
public HttpResponseMessage GetCourseResourceById(int id)
{
try {
Resources resource = this._resourcesManagement.GetResourceById(id);
if (resource != null)
{
ResourcesDTO dto = new ResourcesDTO {
CourseId = resource.CourseId,
FileId = resource.FileId,
FileName = resource.FileName,
ModuleID = resource.ModuleID,
ResourceId = resource.ResourceId,
ResourceType = resource.ResourceType
};
return(Request.CreateResponse <ResourcesDTO>(HttpStatusCode.OK, dto));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Resource Not Found"));
}
}
catch (Exception) {
// Log exception code goes here
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Error occured while executing method."));
}
}
/// <summary>
/// Checks availability of resources in the data base and sufficiency of money
/// </summary>
/// <param name="chossenCoffee"></param>
/// <param name="coins"></param>
/// <param name="price"></param>
/// <returns>True or False</returns>
public static bool ProductChecking(ResourcesDTO chossenCoffee, int coins, int price)
{
var resources = Resources.GetResurces();
int coffee = chossenCoffee.Coffee;
int water = chossenCoffee.Water;
int suger = chossenCoffee.Suger;
int resCoffee = resources.Coffee;
int resSugger = resources.Suger;
int resWater = resources.Water;
if (price > coins)
{
Console.WriteLine("You don`t have enough money");
return(false);
}
if (resWater < water || resCoffee < coffee || resSugger < suger)
{
Console.WriteLine("Sorry, out of coffee, BYE");
Process.GetCurrentProcess().Kill();
}
return(true);
}
/// <summary>
/// Converted resource object to DTO and retrieve single resource with ID
/// </summary>
/// <param name="ID">int</param>
/// <returns>resource DTO object</returns>
public async Task <ActionResult <ResourcesDTO> > GetResourcesByID(int ID)
{
var resources = await _context.Resources.FindAsync(ID);
ResourcesDTO rDTO = ConvertToDTO(resources);
return(rDTO);
}
/// <summary>
/// Convert resources object to DTO object
/// </summary>
/// <param name="resources">resources object</param>
/// <returns>resources DTO object</returns>
public ResourcesDTO ConvertToDTO(Resources resources)
{
ResourcesDTO rDTO = new ResourcesDTO()
{
ID = resources.ID,
Name = resources.Name,
Description = resources.Description,
ResourcesType = resources.ResourcesType
};
return(rDTO);
}
/// <summary>
/// Convert resource object to DTO and get all resources from database
/// </summary>
/// <returns>Resource DTO</returns>
public async Task <List <ResourcesDTO> > GetAllResources()
{
List <Resources> resources = await _context.Resources.ToListAsync();
List <ResourcesDTO> rDTO = new List <ResourcesDTO>();
foreach (var resource in resources)
{
ResourcesDTO RDTO = ConvertToDTO(resource);
rDTO.Add(RDTO);
}
return(rDTO);
}
/// <summary>
/// This procedure is used for the update the resource key value.
/// </summary>
/// <param name="i_sConnectionString">DB Connection string</param>
/// <param name="m_objResourceDTO">Object of Resource DTO</param>
/// <returns>If saves return true otherwise false</returns>
public bool SaveDetails(string i_sConnectionString, ResourcesDTO m_objResourcesDTO)
{
try
{
using (var objResourcesDAL = new ResourcesDAL())
{
return(objResourcesDAL.Save(i_sConnectionString, m_objResourcesDTO));
}
}
catch (Exception exp)
{
throw exp;
}
}
/// <summary>
/// Updates resources table in data base according to the picked coffee
/// </summary>
/// <param name="neededResources"></param>
public static void CoffeeMaking(ResourcesDTO neededResources)
{
var resourc = Resources.GetResurces();
int suger = neededResources.Suger;
int coffee = neededResources.Coffee;
int water = neededResources.Water;
int resCoffee = resourc.Coffee;
int resWater = resourc.Water;
int resSugger = resourc.Suger;
string connectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
string sqlExpression = $"UPDATE Resources SET water={resWater - water}, suger={resSugger - suger}, coffee={resCoffee - coffee} WHERE id=1";
using (var connection = new SqliteConnection(connectionString))
{
connection.Open();
SqliteCommand command = new SqliteCommand(sqlExpression, connection);
command.ExecuteNonQuery();
}
}
/// <summary>
/// Used to choose coffee from product list
/// </summary>
/// <param name="products"></param>
/// <param name="price"></param>
/// <returns>Chosen coffee of ResourcesDTO type</returns>
public static ResourcesDTO ChooseCoffee(List <ProductsDTO> products, out int price)
{
bool rightCoffe;
int requiredId;
price = 0;
ResourcesDTO resources = null;
do
{
Console.WriteLine("You can choose coffee selecting coffee number from 1 to 10");
rightCoffe = Int32.TryParse(Console.ReadLine(), out requiredId);
if (requiredId < 0 || requiredId > 11)
{
rightCoffe = false;
}
} while (!rightCoffe);
var product = products.FirstOrDefault(x => x.RequiredId == requiredId);
if (product != null)
{
resources = new ResourcesDTO()
{
Coffee = product.Coffee,
Water = product.Water,
Suger = product.Suger,
};
price = product.Price;
}
else
{
Process.GetCurrentProcess().Kill();
}
return(resources);
}
public JsonResult UpdateResourceValue(ResourceModel objResourceModel, int acid)
{
bool bReturn = false;
LoginUserDetails objLoginUserDetails = (LoginUserDetails)InsiderTrading.Common.Common.GetSessionValue((string)ConstEnum.SessionValue.UserDetails);
ResourcesSL objResourcesSL = new ResourcesSL();
ResourcesDTO objResourcesDTO = new ResourcesDTO();
CompaniesSL objCompaniesSL = new CompaniesSL();
bool statusFlag = false;
var ErrorDictionary = new Dictionary <string, string>();
Common.Common objCommon = new Common.Common();
string message = string.Empty;
try
{
if (!objCommon.ValidateCSRFForAJAX())
{
return(Json(new
{
status = statusFlag,
Message = ErrorDictionary
}, JsonRequestBehavior.AllowGet));
}
Common.Common.CopyObjectPropertyByName(objResourceModel, objResourcesDTO);
objResourcesDTO.LoggedInUserId = objLoginUserDetails.LoggedInUserID;
bReturn = objResourcesSL.SaveDetails(objLoginUserDetails.CompanyDBConnectionString, objResourcesDTO);
if (bReturn)
{
objCompaniesSL.UpdateMasterCompanyDetails(Common.Common.getSystemConnectionString(), objLoginUserDetails.CompanyName, 1);
Common.Common.UpdateCompanyResources(objLoginUserDetails.CompanyDBConnectionString, objLoginUserDetails.CompanyName);
//return Json(new
//{
// status = true,
// Message = InsiderTrading.Common.Common.getResource("mst_msg_10049") //"Resource Update Successfully."
//}, JsonRequestBehavior.AllowGet);
statusFlag = true;
message = InsiderTrading.Common.Common.getResource("mst_msg_10049");
}
else
{
statusFlag = false;
message = "Resource not saved.";
}
//return Json(new
//{
// status = false,
// Message = "Resource not saved."
//}, JsonRequestBehavior.AllowGet);
}
catch (Exception exp)
{
ModelState.Remove("KEY");
ModelState.Add("KEY", new ModelState());
ModelState.Clear();
string sErrMessage = Common.Common.getResource(exp.InnerException.Data[0].ToString());
ModelState.AddModelError("error", sErrMessage);
ErrorDictionary = GetModelStateErrorsAsString();
}
finally
{
objLoginUserDetails = null;
objResourcesSL = null;
objResourcesDTO = null;
objCompaniesSL = null;
}
return(Json(new
{
status = statusFlag,
Message = message
}, JsonRequestBehavior.AllowGet));
}
