public static void Add(string key, IAuthorizationRequirement requirement)
{
if (Requirments.ContainsKey(key))
{
Requirments[key].Add(requirement);
}
else
{
Requirments.Add(key, new List <IAuthorizationRequirement> {
requirement
});
}
}
public ActionResult Create(Requirments model)
{
try
{
if (ModelState.IsValid)
{
Requirments record = new Requirments();
record.Name = model.Name;
record.Description = model.Description;
record.Code = model.Code;
dbcontext.Requirments.Add(record);
dbcontext.SaveChanges();
//=================================check for alert==================================
var get_result_check = HR.Controllers.check.check_alert("requirmetns", HR.Models.user.Action.Create, HR.Models.user.type_field.form);
if (get_result_check != null)
{
var inbox = new Models.user.Alert_inbox {
send_from_user_id = User.Identity.Name, send_to_user_id = get_result_check.send_to_ID_user, title = get_result_check.Subject, Subject = get_result_check.Message
};
if (get_result_check.until != null)
{
if (get_result_check.until.Value.Year != 0001)
{
inbox.until = get_result_check.until;
}
}
ApplicationDbContext dbcontext = new ApplicationDbContext();
dbcontext.Alert_inbox.Add(inbox);
dbcontext.SaveChanges();
}
//===================================================================================
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
catch (DbUpdateException)
{
TempData["Message"] = HR.Resource.Basic.thiscodeIsalreadyexists;
return(View(model));
}
catch (Exception e)
{
return(View(model));
}
}
public ActionResult Create()
{
//////
var modell = new Requirments();
var stru = dbcontext.StructureModels.FirstOrDefault(m => m.All_Models == ChModels.Organization).Structure_Code;
var model = dbcontext.Requirments.ToList();
if (model.Count() == 0)
{
modell.Code = stru + "1";
}
else
{
modell.Code = stru + (model.LastOrDefault().ID + 1).ToString();
}
/////
return(View(modell));
}
private void Fill_Department()
{
using (DataTable dataTable_Department = Database.Select_Department(Uni_ID))
{
for (int i = 0; i < dataTable_Department.Rows.Count; i++)
{
Department Temp_Department = new Department();
int Dep_ID = (int)dataTable_Department.Rows[i]["Dep_ID"];
using (DataTable dataTable_AvailableTimes = Database.Select_AvailableTimes(Dep_ID))
{
for (int j = 0; j < dataTable_AvailableTimes.Rows.Count; j++)
{
Temp_Department.AvailableTimes.Add(new Duration(GetTime(dataTable_AvailableTimes.Rows[j]["AT_StartTime"]), GetTime(dataTable_AvailableTimes.Rows[j]["AT_FinishTime"])));
}
}
using (DataTable dataTable_Classrooms = Database.Select_Classrooms(Dep_ID))
{
for (int j = 0; j < dataTable_Classrooms.Rows.Count; j++)
{
int Cls_ID = (int)dataTable_Classrooms.Rows[j]["Cls_ID"];
Classroom Temp_Classroom = new Classroom(Cls_ID, (string)dataTable_Classrooms.Rows[j]["Cls_Name"]);
using (DataTable dataTable_ClassroomRequirments = Database.Select_ClassroomRequirments(Cls_ID))
{
for (int k = 0; k < dataTable_ClassroomRequirments.Rows.Count; k++)
{
using (DataTable dataTable_Requirments = Database.Select_Requirments_Req_ID((int)dataTable_ClassroomRequirments.Rows[k]["Req_ID"]))
{
Requirments Temp_Requirments = new Requirments();
Temp_Requirments.ID = (int)dataTable_Requirments.Rows[0]["Req_ID"];
Temp_Requirments.Name = (string)dataTable_Requirments.Rows[0]["Req_Name"];
Temp_Requirments.Count = (int)dataTable_ClassroomRequirments.Rows[k]["Req_ID"];
Temp_Classroom.AddRequirments(Temp_Requirments);
}
}
}
Temp_Department.Classrooms.Add(Temp_Classroom);
}
}
Departments.Add(new Tuple <Department, int>(Temp_Department, Dep_ID));
}
}
}
public static void Main()
{
extra E = new extra();
Requirments R = new Requirments();
Algorithms A = new Algorithms();
//R.array= read_single("Open_128.txt");
//A.sort(R.array);
//E.print(R.array);
//reference arrays
string[] names = { "Change_1024.txt", "Change_256.txt", "Change_128.txt", "Close_1024.txt", "Close_256.txt", "Close_128.txt", "High_1024.txt", "High_256.txt", "High_128.txt", "Low_1024.txt", "Low_256.txt", "Low_128.txt", "Open_1024.txt", "Open_256.txt", "Open_128.txt" };
string[] algorithms = { "bubble_sort", "quick_sort", "merge_sort", "insertion_sort", "binary_search", "linear_search" };
Console.Clear();
int count = 0;
foreach (string s in names)
{
Console.WriteLine("({0}) {1} ", count, s);
count++;
} //prints the names of the arrays
//part of the display
//gets user input of which array they want
Console.WriteLine("Please choose one off the arrays by typing the refernce number to the left");
int input1; //array needed
while (true)
{
while (!int.TryParse(Console.ReadLine(), out input1)) //only runs if its not a number
{
Console.WriteLine("please enter a valid number");
}
if (input1 >= 0 && input1 <= 14) //makes sure input is within the list range
{
break;
}
}
R.array = read_single(names[input1]); //creates and array of selected file
//its stored in Requirements
//this sections gets the direction of the sorted array
while (true)
{
Console.WriteLine("would you like it in accending or decending order A/D");
R.order = Console.ReadLine();
R.order = R.order.ToLower();
if (R.order == "a")
{
Console.WriteLine("you've chosen accending order");
break;
}
if (R.order == "d")
{
Console.WriteLine("you've chosen decending order");
break;
}
else
{
Console.WriteLine("please choose a valid input");
}
}
Console.ReadKey();
//R.order is set here
//the following section is for getting the algorithm
Console.Clear();
count = 0; // resets count from before
foreach (string s in algorithms)
{
Console.WriteLine("({0}) {1} ", count, s);
count++;
} //prints the algorithm names
Console.WriteLine("please enter the reference number of an algorithm on the left");
int process;
while (true)
{
while (!int.TryParse(Console.ReadLine(), out process)) //only runs if its not a number
{
Console.WriteLine("not a valid reference");
}
if (process >= 0 && process <= 5) //makes sure input is within the list range
{
break;
}
}
switch (process)
{
case 0:
{
Console.Clear();
Console.WriteLine("bubble_sort");
A.bubble(R.array);
R.iterations = A.counter;
A.counter = 0;
E.print(R.array, R.order, R.iterations);
break;
}
case 1:
{
Console.Clear();
Console.WriteLine("quick_sort");
A.QuickSort(R.array);
R.iterations = A.counter;
A.counter = 0;
E.print(R.array, R.order, R.iterations);
break;
}
case 2:
{
Console.Clear();
Console.WriteLine("merge_sort");
R.array = A.MergeSort(R.array);
R.iterations = A.counter;
A.counter = 0;
E.print(R.array, R.order, R.iterations);
break;
}
case 3:
{
Console.Clear();
Console.WriteLine("insertion_sort");
A.insertionsort(R.array);
R.iterations = A.counter;
A.counter = 0;
E.print(R.array, R.order, R.iterations);
break;
}
case 4:
{ //iterations is still broken on this
Console.Clear();
Console.WriteLine("binary_search");
A.QuickSort(R.array);
E.print(R.array, R.order);
A.counter = 0;
int result = A.binary_search(R.array);
Console.WriteLine("iterations:{0}", R.iterations);
if (result >= 0)
{
Console.WriteLine("your search was found at index:{0}", result);
}
else
{
Console.WriteLine();
}
break;
}
case 5:
{
Console.Clear();
Console.WriteLine("linear_search");
A.QuickSort(R.array);
E.print(R.array, R.order);
A.linear(R.array);
R.iterations = A.counter;
A.counter = 0;
break;
}
default:
break;
} //switch statement
Console.WriteLine();
Console.WriteLine("go again? y/n");
string input = Console.ReadLine();
input = input.ToLower();
if (input == "y")
{
Main();
}
} //main
