public bool TryLogin(IFormCollection form, out LoginFormErrorViewModel error)
{
var email = form.ContainsKey("email") ? form["email"].ToString() : "";
var password = form.ContainsKey("password") ? form["password"].ToString() : "";
var success = true;
error = new LoginFormErrorViewModel()
{
Errors = new List <string>(),
Email = email,
Message = ""
};
if (!IsAlreadyRegisteredEmail(email))
{
success = false;
error.Errors.Add("Email does not exist!");
}
if (!PasswordCorrect(email, password))
{
success = false;
error.Errors.Add("Password is not correct!");
}
return(success);
}
public IActionResult Index(IFormCollection fc)
{
var pager = new Pager(1);
var profile = GetProfile();
var model = new AdminPostsModel {
Profile = profile
};
var status = fc.ContainsKey("status-filter") ? fc["status-filter"].ToString() : "A";
model.StatusFilter = GetStatusFilter(status);
var selectedCategories = new List <string>();
var dbCategories = new List <Category>();
model.CategoryFilter = _db.Categories.CategoryList(c => c.ProfileId == model.Profile.Id).ToList();
if (fc.ContainsKey("category-filter"))
{
selectedCategories = fc["category-filter"].ToList();
foreach (var ftr in model.CategoryFilter)
{
if (selectedCategories.Contains(ftr.Value))
{
ftr.Selected = true;
}
}
}
model.BlogPosts = _db.BlogPosts.ByFilter(status, selectedCategories, profile.Slug, pager).Result;
model.Pager = pager;
return(View(_theme + "Index.cshtml", model));
}
/// <remarks>
/// There doesn't seem to be a way of binding files to a model natively using Azure Functions.
/// </remarks>
/// <summary>
/// Binds form data and file uploads to a <see cref="Document"/> model.
/// </summary>
private Document BindToDocument(IFormCollection form)
{
if (!form.ContainsKey("Name"))
{
return(null);
}
IFormFile file = form.Files.GetFile("Content");
if (file == null)
{
return(null);
}
Document document = new Document();
document.Name = form["Name"];
if (form.ContainsKey("Name"))
{
int.TryParse(form["Order"], out int order);
document.Order = order;
}
using (var fileStream = file.OpenReadStream())
{
document.Content = new byte[file.Length];
fileStream.Read(document.Content, 0, (int)file.Length);
}
return(document);
}
/// <summary>
/// Checks the request for the standard user actions for the plattform
/// based on
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static UserActionType GetStandardUserAction(HttpRequest request)
{
if (request != null && request.Method.ToUpper() == "POST")
{
IFormCollection form = request.Form;
if (form.ContainsKey("NavigationButtonNext"))
{
return(UserActionType.NavigateNext);
}
if (form.ContainsKey("NavigationButtonPrevious"))
{
return(UserActionType.NavigatePrevious);
}
if (form.ContainsKey("NavigationButtonSubmit"))
{
return(UserActionType.Submit);
}
if (form.ContainsKey("NavigationButtonValidate") ||
!string.IsNullOrEmpty(request.Query["Validate"]))
{
return(UserActionType.Validate);
}
}
return(UserActionType.Default);
}
public async Task <IActionResult> Settings(OrderSetttingsView model, IFormCollection form, CancellationToken cancellationToken)
{
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId);
var settings = await _resourceOrdersService.GetSettingsByDepartmentIdAsync(DepartmentId);
if (ModelState.IsValid)
{
if (settings == null)
{
settings = new ResourceOrderSetting();
settings.DepartmentId = DepartmentId;
settings.ImportEmailCode = RandomGenerator.GenerateRandomString(6, 6, false, true, false, true, true, false, null);
}
settings.AllowedStaffingLevelToReceiveNotifications = model.Settings.AllowedStaffingLevelToReceiveNotifications;
settings.AutomaticFillAcceptance = model.Settings.AutomaticFillAcceptance;
settings.BoundryGeofence = model.Settings.BoundryGeofence;
settings.DefaultResourceOrderManagerUserId = model.Settings.DefaultResourceOrderManagerUserId;
settings.DoNotReceiveOrders = model.Settings.DoNotReceiveOrders;
settings.LimitStaffingLevelToReceiveNotifications = model.Settings.LimitStaffingLevelToReceiveNotifications;
settings.NotifyUsers = model.Settings.NotifyUsers;
settings.Range = model.Settings.Range;
settings.RoleAllowedToFulfilOrdersRoleId = model.Settings.RoleAllowedToFulfilOrdersRoleId;
settings.Visibility = model.Settings.Visibility;
if (form.ContainsKey("departmentTypes"))
{
settings.TargetDepartmentType = form["departmentTypes"].ToString();
}
if (form.ContainsKey("notifyRoles"))
{
settings.UserIdsToNotifyOnOrders = form["notifyRoles"].ToString();
}
await _resourceOrdersService.SaveSettingsAsync(settings, cancellationToken);
return(RedirectToAction("Index"));
}
model.OrderVisibilities = model.Visibility.ToSelectListInt();
var staffingLevels = await _customStateService.GetActiveStaffingLevelsForDepartmentAsync(DepartmentId);
if (staffingLevels == null)
{
model.StaffingLevels = model.UserStateTypes.ToSelectListInt();
}
else
{
model.StaffingLevels = new SelectList(staffingLevels.GetActiveDetails(), "CustomStateDetailId", "ButtonText");
}
model.SetUsers(await _departmentsService.GetAllUsersForDepartmentAsync(DepartmentId, false, true), await _departmentsService.GetAllPersonnelNamesForDepartmentAsync(DepartmentId));
return(View(model));
}
public async Task <VerifyGatewayResult> VerifyGateway(VerifyGatewayRequest request, PaymentGatewayRequest gatewayRequest, IFormCollection form)
{
if (form == null)
{
return(VerifyGatewayResult.Failed("Form verisi alınamadı."));
}
if (!form.ContainsKey("BankPacket") || !form.ContainsKey("MerchantPacket") || !form.ContainsKey("Sign"))
{
return(VerifyGatewayResult.Failed("Form verisi alınamadı."));
}
var merchantId = request.BankParameters["merchantId"];
var terminalId = request.BankParameters["terminalId"];
string requestXml = $@"<?xml version=""1.0"" encoding=""utf-8""?>
<posnetRequest>
<mid>{merchantId}</mid>
<tid>{terminalId}</tid>
<oosResolveMerchantData>
<bankData>{form["BankPacket"]}</bankData>
<merchantData>{form["MerchantPacket"]}</merchantData>
<sign>{form["Sign"]}</sign>
</oosResolveMerchantData>
</posnetRequest>";
var httpParameters = new Dictionary <string, string>();
httpParameters.Add("xmldata", requestXml);
var response = await client.PostAsync(request.BankParameters["verifyUrl"], new FormUrlEncodedContent(httpParameters));
string responseContent = await response.Content.ReadAsStringAsync();
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(responseContent);
if (xmlDocument.SelectSingleNode("posnetResponse/approved") == null ||
xmlDocument.SelectSingleNode("posnetResponse/approved").InnerText != "1" ||
xmlDocument.SelectSingleNode("posnetResponse/approved").InnerText != "2")
{
string errorMessage = "3D doğrulama başarısız.";
if (xmlDocument.SelectSingleNode("posnetResponse/respText") != null)
{
errorMessage = xmlDocument.SelectSingleNode("posnetResponse/respText").InnerText;
}
return(VerifyGatewayResult.Failed(errorMessage, form["ApprovedCode"],
xmlDocument.SelectSingleNode("posnetResponse/approved").InnerText));
}
int.TryParse(form["InstalmentNumber"], out int instalmentNumber);
return(VerifyGatewayResult.Successed(form["HostLogKey"], $"{form["HostLogKey"]}-{form["AuthCode"]}",
instalmentNumber, 0,
xmlDocument.SelectSingleNode("posnetResponse/respText")?.InnerText,
form["ApprovedCode"]));
}
public PartialViewResult FilterIndex(IFormCollection collection)
{
var filteredPosts = _context.Posts.Select(p => p);
//Filtered by posted date
var duration = collection.ContainsKey("duration") == false ? "all" : collection["duration"][0];
switch (duration)
{
case "today":
filteredPosts = filteredPosts.Where(p => p.PostedDate.Date == DateTime.Now.Date);
break;
case "3days":
filteredPosts = filteredPosts.Where(p => p.PostedDate.Date.AddDays(3) >= DateTime.Now.Date);
break;
case "week":
filteredPosts = filteredPosts.Where(p => p.PostedDate.Date.AddDays(7) >= DateTime.Now.Date);
break;
default:
break;
}
//Filter by category
var category = collection["category"].ToArray();
if (category.Length != 0)
{
filteredPosts = filteredPosts.Where(p => category.Contains(p.Category.Name));
}
//Filter by animal
var animal = collection["animal"].ToArray();
if (animal.Length != 0)
{
filteredPosts = filteredPosts.Where(p => animal.Contains(p.Animal.Name));
}
//Filter by area
var area = collection.ContainsKey("area") == false ? "all" : collection["area"][0];
if (area != "all")
{
filteredPosts = filteredPosts.Where(p => p.City.Name == area);
}
//Search by title
var search = collection.ContainsKey("searchcontent").ToString() == "" ? "all" : collection["searchcontent"][0];
if (search != "all")
{
filteredPosts = filteredPosts.Where(p => p.Title.Contains(search));
}
return(PartialView("NewsFeedPartial", filteredPosts.Include(c => c.Category).ToList()));
}
public static bool TryParseForm(IFormCollection form, out Cooking cooking, out string error, bool generateId = false)
{
cooking = null;
error = "";
string id;
if (generateId)
{
id = Guid.NewGuid().ToString("N");
}
else
{
if (!form.ContainsKey("id"))
{
error = "'id' is missing";
return(false);
}
id = form["id"];
}
cooking = new Cooking()
{
Id = id,
};
if (!form.ContainsKey("date"))
{
error = "'date' is missing";
return(false);
}
cooking.Date = form["date"];
if (!form.ContainsKey("meal"))
{
error = "'meal' is missing.";
return(false);
}
if (!form.ContainsKey("price"))
{
error = "'price' is missing";
return(false);
}
if (!uint.TryParse(form["price"], out var price))
{
error = "'price' is not an uint";
return(false);
}
;
cooking.Meal = form["meal"];
cooking.Participants = new List <string>();
cooking.Price = price;
return(true);
}
public async Task <String> LockRoster(IFormCollection forms)
{
var currentSeason = await _dataService.GetCurrentSeasonId();
var schoolId = await _dataService.GetSchoolIdAsync(User);
if (schoolId == -1)
{
return("SCHOOL NOT FOUND");
}
string _id = "", side = "", lockState = "";
int id = -1;
if (!forms.ContainsKey("id") &&
!forms.ContainsKey("side") &&
!forms.ContainsKey("lockState"))
{
return("INVALID FORM");
}
// Read in form data
_id = forms["id"];
side = forms["side"];
lockState = forms["lockState"];
// Validate form data
Int32.TryParse(_id, out id);
if (side != "home" && side != "away")
{
return("UNKNOWN SIDE");
}
var match = await _context.Match.FirstOrDefaultAsync(m => m.MatchId == id && (m.HomeSchoolId == schoolId || m.AwaySchoolId == schoolId));
if (match == null)
{
return("NOT FOUND");
}
if (side == "home")
{
match.HomeRosterLocked = lockState == "true";
}
else if (side == "away")
{
match.AwayRosterLocked = lockState == "true";
}
_context.Update(match);
await _context.SaveChangesAsync();
return(lockState == "true" ? "LOCKED" : "UNLOCKED");
}
public IActionResult Register(IFormCollection form)
{
var regSuccess = TryRegister(form, out RegisterFormErrorViewModel errors);
if (regSuccess)
{
var email = form.ContainsKey("email") ? form["email"].ToString() : "";
var password = form.ContainsKey("password") ? form["password"].ToString() : "";
var privkey = form.ContainsKey("privkey") ? form["privkey"].ToString() : "";
var salt = Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 8);
var hashed = PasswordHash(password, salt);
var user = new User()
{
Email = email,
Salt = salt,
HashedPassword = hashed,
HistoricalTransactions = new List <HistoricalTransaction>(),
RegisteredTime = DateTime.UtcNow,
UId = Guid.NewGuid().ToString(),
UserTokens = new List <UserToken>(),
Wallets = new List <Wallet>()
};
context.Database.EnsureCreated();
context.Users.Add(user);
if (privkey != "")
{
var wallet = walletUtil.WalletFromKey(privkey, user, "Main");
context.Wallets.Add(wallet);
}
else
{
var wallet = walletUtil.GenerateNewWallet(user, "Main");
context.Wallets.Add(wallet);
}
context.SaveChanges();
var sucError = new LoginFormErrorViewModel()
{
Email = email,
Errors = new List <string>(),
Message = "<span class='text-success'>Registered succesfully ! Now log in.</span>"
};
return(new RedirectToActionResult("Login", "Home", routeValues: sucError));
}
else
{
return(new RedirectToActionResult("Register", "Home", routeValues: errors));
}
}
public static bool IsValidForm(IFormCollection form)
{
if (form.ContainsKey("username") && form.ContainsKey("password") && form.ContainsKey("registrant") &&
!string.IsNullOrWhiteSpace(form["username"][0]) &&
!string.IsNullOrWhiteSpace(form["password"][0]) &&
!string.IsNullOrWhiteSpace(form["registrant"][0]))
{
return(true);
}
return(false);
}
public async Task <IActionResult> Index(IFormCollection request)
{
try
{
if (!IsValid(Request.Headers))
{
return(Problem(StatusCodes.Status401Unauthorized));
}
if (request.ContainsKey("Object") && request.ContainsKey("Param"))
{
string result = null;
var obj = request["Object"].ToString();
var key = request["Param"].ToString();
if (request.ContainsKey("Value"))
{
var val = request["Value"].ToString();
if (await SetValueAsync(obj, key, val))
{
result = val;
}
}
else
{
result = await GetValueAsync(obj, key);
}
if (result == null)
{
return(Problem(StatusCodes.Status400BadRequest));
}
else
{
var reply = new
{
status = StatusCodes.Status200OK,
result
};
return(Json(reply));
}
}
else
{
return(Problem(StatusCodes.Status400BadRequest));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public IBaseModel GetPartialModel(IFormCollection requestForm)
{
var model = new Template02ViewModel();
if (requestForm.ContainsKey("Title"))
{
model.Title = requestForm["Title"].Last();
}
if (requestForm.ContainsKey("Chapter"))
{
model.Chapter = requestForm["Chapter"].Last();
}
return(model);
}
// TODO: Unit tests
public static List <TestCaseDto> ReadTestCases([NotNull] HttpRequest request)
{
var testCases = new List <TestCaseDto>();
if (!request.HasFormContentType)
{
return(testCases);
}
var indexes = new HashSet <int>(); // list of test case indexes
IFormCollection form = request.Form;
foreach (var key in form.Keys)
{
if (key.StartsWith("TestCases["))
{
var match = TestCaseKeyRegex.Match(key);
if (!match.Success || match.Groups.Count != 2)
{
continue;
}
int index = 0;
if (int.TryParse(match.Groups[1].Value, out index))
{
indexes.Add(index);
}
}
}
foreach (var idx in indexes)
{
string nameKey = $"TestCases[{idx}].TestCaseDtoName";
string codeKey = $"TestCases[{idx}].BenchmarkCode";
if (form.ContainsKey(nameKey) && form.ContainsKey(codeKey))
{
var name = form[nameKey];
var code = form[codeKey];
var testCase = new TestCaseDto()
{
BenchmarkCode = code,
TestCaseName = name
};
testCases.Add(testCase);
}
}
return(testCases);
}
public static void EditModel(string typeName, int id, IFormCollection changes)
{
var model = Repository
.GetModelsByTypeName(typeName, true)
.First(m => m.Id == id);
var isChanged = false;
foreach (var property in IModel.GetBasicProperties(model).Where(p => p.Name != "Id"))
{
if (!changes.ContainsKey(property.Name))
{
continue;
}
isChanged = true;
property.SetValue(model, property.PropertyType == typeof(int)
? (object)int.Parse(changes[property.Name].ToString())
: changes[property.Name].ToString());
}
if (!isChanged)
{
return;
}
model.Save();
Repository.SaveChanges();
}
public string TryValidate(IFormCollection form, Func <RequestBodyData, string, string> onIteration = null)
{
foreach (var item in BodyData)
{
if (!form.ContainsKey(item.Name))
{
return($"Request does not have the field '{item.Name}' available.");
}
string data = form[item.Name];
if (string.IsNullOrWhiteSpace(data) && !item.Required)
{
continue;
}
if (data.Length > item.Max || data.Length < item.Min)
{
return($"Data for field '{item.Name}' is invalid. ({(item.Required ? "" : "not ")}required, min: {item.Min} max: {item.Max})");
}
var result = onIteration?.Invoke(item, data);
if (result != null)
{
return(result);
}
}
return(null);
}
public static bool IsValid(this IFormCollection collection, Type type)
{
var properties = type.GetProperties();
foreach (var property in properties)
{
if (property.Name.Contains("TemplateId") || property.Name.Contains("ChapterSelect"))
{
continue;
}
if (property.Name.Contains("ImgUrl") && (collection.Files.Count > 0))
{
if (collection.Files[int.Parse(property.Name.Substring(6, 1))] == null)
{
return(false);
}
}
else
{
if (!collection.ContainsKey(property.Name))
{
return(false);
}
}
}
return(true);
}
public virtual IActionResult ExportExcel(IFormCollection fc, int page = 1, int rows = 1000000)
{
var query = this.FormCollectionToDictionary(fc);
foreach (var item in Request.Query.Keys)
{
if (!fc.ContainsKey(item.ToString()))
{
query.Add(item.ToString(), Request.Query[item].ToStr());
}
}
var url = ((Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.HttpRequestHeaders)HttpContext.Request.Headers).HeaderReferer.ToStr();
var dic = this.GetUrlQueryString(url);
foreach (var item in dic)
{
if (!query.ContainsKey(item.Key))
{
query.Add(item.Key, item.Value);
}
}
var pe = GetPagingEntity(query, page, rows);
return(File(DBToExcel(pe), Tools.GetFileContentType[".xls"].ToStr(), Guid.NewGuid().ToString() + ".xls"));
}
public String PostFile([FromForm] IFormCollection formCollection)
{
String result = "Fail";
if (formCollection.ContainsKey("user"))
{
var user = formCollection["user"];
}
FormFileCollection fileCollection = (FormFileCollection)formCollection.Files;
foreach (IFormFile file in fileCollection)
{
StreamReader reader = new StreamReader(file.OpenReadStream());
String content = reader.ReadToEnd();
String name = file.FileName;
String filename = @"D:/Test/" + name;
if (System.IO.File.Exists(filename))
{
System.IO.File.Delete(filename);
}
using (FileStream fs = System.IO.File.Create(filename))
{
// 复制文件
file.CopyTo(fs);
// 清空缓冲区数据
fs.Flush();
}
result = "Success";
}
return(result);
}
public void Bind(IFormCollection requestForm)
{
var model = new Template01Model(requestForm);
var wrapper = new StorageManager();
wrapper.WriteModelToDat(model);
if (requestForm.ContainsKey("OldChapter"))
{
var oldChapter = requestForm["OldChapter"].Last();
var oldArticle = requestForm["OldArticle"].Last();
wrapper.WriteOldData(oldChapter, oldArticle);
}
else
{
wrapper.WriteOldData("", "");
}
Title = model.Title;
Description = model.Description;
Chapter = model.Chapter;
using (var binaryReader = new BinaryReader(model.ImgUrl0.OpenReadStream()))
{
ImgUrl0 = binaryReader.ReadBytes((int)model.ImgUrl0.Length);
}
}
public async Task <ActionResult> CreateAsync(IFormCollection collection)
{
try
{
var requestEnvironment = new RaaSP_Portal_External.DataAccess.Models.Request.Environment();
var environment = new Microsoft.Extensions.Primitives.StringValues();
var requestUser = new User();
var user = new Microsoft.Extensions.Primitives.StringValues();
collection.TryGetValue("user", out user);
//TODO: Cast Form Object to Environment Model
Uri businessUser = await CreateUserRequestAsync(requestUser);
if (collection.ContainsKey("environment"))
{
collection.TryGetValue("environment", out environment);
//TODO: Cast Form Object to Environment Model
Uri businessEnvironment = await CreateEnvironmentRequestAsync(requestEnvironment);
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public IActionResult Search(IFormCollection formData, string searchTerm = "", string searchKey = "")
{
var result = _uow.ServicesRepository.GetAll().ToHashSet();
// check advanced search
#region Filter by active
if (formData.ContainsKey("Active") && bool.Parse(formData["Active"]))
{
result = result.Where(ent => ent.IsActive).ToHashSet();
}
#endregion
#region Filter by Code
if (!string.IsNullOrEmpty(formData["Code"]))
{
result = result.Where(tt => !string.IsNullOrEmpty(tt.Code) && tt.Code.ToLower().Contains(formData["Code"].ToString().ToLower().Trim())).ToHashSet();
}
#endregion
#region Filter by ArabicName
if (!string.IsNullOrEmpty(formData["ArabicName"]))
{
result = result.Where(tt => !string.IsNullOrEmpty(tt.ArabicName) && tt.ArabicName.ToLower().Contains(formData["ArabicName"].ToString().ToLower().Trim())).ToHashSet();
}
#endregion
#region Filter by EnglishName
if (!string.IsNullOrEmpty(formData["EnglishName"]))
{
result = result.Where(tt => !string.IsNullOrEmpty(tt.EnglishName) && tt.EnglishName.ToLower().Contains(formData["EnglishName"].ToString().ToLower().Trim())).ToHashSet();
}
#endregion
// checkالبحث العادي
if (!string.IsNullOrEmpty(searchKey) && !string.IsNullOrEmpty(searchTerm))
{
searchTerm = searchTerm.Trim().ToLower();
switch (searchKey.ToLower())
{
case "arabicname":
result = result.Where(ent => !string.IsNullOrEmpty(ent.ArabicName) && ent.ArabicName.ToLower().Contains(searchTerm)).ToHashSet();
break;
case "englishname":
result = result.Where(ent => !string.IsNullOrEmpty(ent.EnglishName) && ent.EnglishName.ToLower().Contains(searchTerm)).ToHashSet();
break;
case "code":
result = result.Where(ent => !string.IsNullOrEmpty(ent.Code) && ent.Code.ToLower().Contains(searchTerm)).ToHashSet();
break;
case "active":
result = result.Where(ent => (ent.IsActive)).ToHashSet();
break;
default:
break;
}
}
result = result.OrderByDescending(ent => ent.CreationDate).ToHashSet();
return(PartialView("_List", result));
}
public Transaction SendTransaction(User usr, Wallet wallet, IFormCollection form)
{
UpdatePeers();
var from = "";
if (form.ContainsKey("wallet"))
{
if (form["wallet"].ToString().Split('-').Length > 1)
{
from = form["wallet"].ToString().Split('-')[1];
}
}
var target = GetVoutsFromForm(form, from);
var unspent = GetUnspentVOutsForAddress(from);
if (target.FindAll(r => r.Amount <= 0).Count > 0)
{
return(null);
}
if (target.Sum(r => r.Amount) > unspent.Sum(r => r.Amount))
{
return(null);
}
var trans = transactionUtil.GetTransactionFromForm(wallet, usr, form, target, unspent);
return(SendMadeTransaction(trans));
}
public List <InBlockTransactionVOut> GetVoutsFromForm(IFormCollection form, string fromaddr)
{
var outV = new List <InBlockTransactionVOut>();
for (int ii = 0; ii < 100; ii++)
{
if (form.ContainsKey($"toaddr{ii}"))
{
try
{
var am = float.Parse(form[$"ammount{ii}"]);
var to = form[$"toaddr{ii}"];
var vout = new TransactionVOut()
{
Amount = (long)(am * 100000f),
FromAddress = fromaddr,
ToAddress = to,
FromBlock = ""
};
TransactionVOut.SetUniqueIdForVOut(vout);
outV.Add(vout.GetInBlockTransactionVOut());
}
catch
{
continue;
}
}
}
return(outV);
}
public async Task <IActionResult> SavePersonnelStatusListOrdering(IFormCollection form, CancellationToken cancellationToken)
{
List <int> options = (from object key in form.Keys
where key.ToString().StartsWith("personnelStatus_")
select int.Parse(key.ToString().Replace("personnelStatus_", ""))).ToList();
if (options != null || options.Any())
{
var personnelStatusOrdering = new List <PersonnelListStatusOrder>();
foreach (var i in options)
{
if (form.ContainsKey("personnelStatus_" + i))
{
var weight = form["personnelStatus_" + i];
var statusId = form["personnelStatusValue_" + i];
var statusOrder = new PersonnelListStatusOrder();
statusOrder.Weight = int.Parse(weight);
statusOrder.StatusId = int.Parse(statusId);
personnelStatusOrdering.Add(statusOrder);
}
}
if (personnelStatusOrdering.Any())
{
personnelStatusOrdering = personnelStatusOrdering.OrderBy(x => x.Weight).ToList();
}
await _departmentSettingsService.SetDepartmentPersonnelListStatusSortOrderAsync(DepartmentId, personnelStatusOrdering, cancellationToken);
}
return(RedirectToAction("ListOrdering"));
}
public ActionResult Setting(IFormCollection form)
{
var cx = SmartHomeDBContext.Create(AppSettings);
Guid gid = new Guid(AppSettings.UNIT1);
var model = cx.Devices.Single(e => e.DeviceId == gid);
var conf = SmartHomeConfig.Deserialize(model.Config);
conf.dogontemp = int.Parse(form["dogontemp"]);
conf.irrigationOn = (form["irrigationOn"].Contains("true"));
conf.christmasOn = (form["christmasOn"].Contains("true"));
conf.ClearWaterItems();
for (int i = 0; i < 20; i++)
{
string f = "irrigation" + i.ToString();
if (form.ContainsKey(f))
{
var itm = new SmartHomeConfig.MySmartHomeConfigWaterItem();
itm.starthour = form[f];
itm.intervalsec = int.Parse(form[f + "m"]) * 60;
conf.AddWaterItem(itm);
}
}
model.Config = conf.Serialize();
cx.SaveChanges();
return(View(conf));
}
public IActionResult EditSubmit(IFormCollection keyValuePairs)
{
var bookname = keyValuePairs["bookname"][0];
var bookprice = keyValuePairs["bookprice"][0];
var bookinstock = "off";
if (keyValuePairs.ContainsKey("bookinstock"))
{
bookinstock = keyValuePairs["bookinstock"][0];
}
var categoryid = keyValuePairs["category"][0];
var bookid = keyValuePairs["bookid"][0];
Books books = new Books();
books.BookName = bookname;
books.BookId = Convert.ToInt32(bookid);
books.BookPrice = Convert.ToDecimal(bookprice);
if (bookinstock == "on")
{
books.BookInStock = true;
}
else
{
books.BookInStock = false;
}
books.CategoryId = Convert.ToInt32(categoryid);
bookservices.EditBook(books);
return(RedirectToAction("Index"));
}
public Job AddJob(IFormCollection form, SessionData sd)
{
if (!form.ContainsKey("name") || !form.ContainsKey("wage") || !form.ContainsKey("rules"))
{
return(null);
}
if (string.IsNullOrEmpty(form["name"][0]) || string.IsNullOrEmpty(form["wage"][0]) ||
string.IsNullOrEmpty(form["rules"][0]))
{
return(null);
}
string title = form["name"][0];
if (!decimal.TryParse(form["wage"][0], out var wage))
{
return(null);
}
var rules = JsonConvert.DeserializeObject <List <Rule> >(form["rules"][0]);
if (rules == null)
{
return(null);
}
var job = new Job()
{
Name = title,
Hourly = wage,
Id = Guid.NewGuid().ToString("N").Substring(8),
Rules = rules
};
var user = GetUser(sd.Username);
user.Jobs.Add(job);
_users.Update(user);
return(job);
}
internal static SlackCallback AsSlackCallback(this IFormCollection form)
{
if (form == null || !form.ContainsKey("payload"))
{
return(null);
}
return(WebUtility.UrlDecode(form["payload"].ToString()).FromJson <SlackCallback>());
}
public IActionResult EditList(EditListView model, IFormCollection collection)
{
var list = _distributionListsService.GetDistributionListById(model.List.DistributionListId);
model.Users = _departmentsService.GetAllUsersForDepartment(DepartmentId);
model.ListTypes = model.Type.ToSelectList();
if (!model.List.UseSsl.HasValue)
{
model.List.UseSsl = false;
}
if (model.Type == DistributionListTypes.External && !StringHelpers.IsValidDomainName(model.List.Hostname))
{
ModelState.AddModelError("List.Hostname", string.Format("The hostname supplied is not valid, must looks somthing like mail.mydepartment.com."));
}
if (ModelState.IsValid)
{
model.List.DepartmentId = DepartmentId;
model.List.Members = new Collection <DistributionListMember>();
list.Name = model.List.Name;
list.IsDisabled = model.List.IsDisabled;
list.Type = (int)DistributionListTypes.Internal;
list.EmailAddress = model.List.EmailAddress;
list.Hostname = null;
list.Port = null;
list.UseSsl = null;
list.Username = null;
list.Password = null;
list.Members = new Collection <DistributionListMember>();
if (collection.ContainsKey("listMembers"))
{
var userIds = collection["listMembers"].ToString().Split(char.Parse(","));
foreach (var userId in userIds)
{
var member = new DistributionListMember();
member.UserId = userId;
list.Members.Add(member);
}
}
_distributionListsService.SaveDistributionList(list);
return(RedirectToAction("Index", "DistributionLists", new { Area = "User" }));
}
return(View(model));
}
