public static void Run([TimerTrigger("0 0 18 * * *")] TimerInfo myTimer, ILogger log)
{
var str = Environment.GetEnvironmentVariable("bloombergsql");
var securities = new List <SecurityModel>();
using (SqlConnection conn = new SqlConnection(str))
{
conn.Open();
log.LogInformation("connection success");
StringBuilder sb = new StringBuilder();
sb.Append("SELECT * ");
sb.Append("FROM [dbo].[Securities];");
String sql = sb.ToString();
log.LogInformation("query string creation success");
using (SqlCommand cmd = new SqlCommand(sql, conn))
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
log.LogInformation("reader success");
while (reader.Read())
{
var security = new SecurityModel(reader.GetInt32(0), reader.GetString(1));
securities.Add(security);
}
}
}
}
BloombergNormalization.getBloombergData(securities, log);
}
public void SecurityModelNoFlySelecteeTest()
{
var model = new SecurityModel();
var first = model.NoFlySelectee.FirstOrDefault();
Assert.IsNotNull(first);
}
public GetMaximumOrderQuantityResult GetMaximumOrderQuantityForDeltaBuyingPower(
GetMaximumOrderQuantityForDeltaBuyingPowerParameters parameters
)
{
EnsureSecurityExists(parameters.Security);
var expected = SecurityModel.GetMaximumOrderQuantityForDeltaBuyingPower(parameters);
if (reentry)
{
return(expected);
}
reentry = true;
var security = parameters.Security;
var positionGroup = Portfolio.Positions[new PositionGroupKey(PositionGroupModel, security)];
var actual = PositionGroupModel.GetMaximumLotsForDeltaBuyingPower(
new GetMaximumLotsForDeltaBuyingPowerParameters(
parameters.Portfolio,
positionGroup,
parameters.DeltaBuyingPower,
parameters.MinimumOrderMarginPortfolioPercentage,
parameters.SilenceNonErrorReasons
)
);
var lotSize = security.SymbolProperties.LotSize;
Assert.AreEqual(expected.IsError, actual.IsError,
$"{PositionGroupModel.GetType().Name}:{nameof(GetMaximumOrderQuantityForDeltaBuyingPower)}: " +
$"ExpectedQuantity: {expected.Quantity} ActualQuantity: {actual.NumberOfLots * lotSize} {Environment.NewLine}" +
$"ExpectedReason: {expected.Reason}{Environment.NewLine}" +
$"ActualReason: {actual.Reason}"
);
// we're not comparing group quantities, which is the number of position lots, but rather the implied
// position quantities resulting from having that many lots.
var resizedPositionGroup = positionGroup.WithQuantity(actual.NumberOfLots);
var position = resizedPositionGroup.GetPosition(security.Symbol);
var bpmOrder = new MarketOrder(security.Symbol, expected.Quantity, parameters.Portfolio.Securities.UtcTime);
var pgbpmOrder = new MarketOrder(security.Symbol, position.Quantity, parameters.Portfolio.Securities.UtcTime);
var bpmMarginRequired = security.BuyingPowerModel.GetInitialMarginRequirement(security, bpmOrder.Quantity);
var pgbpmMarginRequired = PositionGroupModel.GetInitialMarginRequiredForOrder(Portfolio, resizedPositionGroup, pgbpmOrder);
var availableBuyingPower = security.BuyingPowerModel.GetBuyingPower(parameters.Portfolio, security, bpmOrder.Direction);
Assert.AreEqual(expected.Quantity, position.Quantity,
$"{PositionGroupModel.GetType().Name}:{nameof(GetMaximumOrderQuantityForDeltaBuyingPower)}: " +
$"ExpectedReason: {expected.Reason}{Environment.NewLine}" +
$"ActualReason: {actual.Reason}"
);
Assert.AreEqual(expected.Reason, actual.Reason,
$"{PositionGroupModel.GetType().Name}:{nameof(GetMaximumOrderQuantityForDeltaBuyingPower)}"
);
reentry = false;
return(expected);
}
public HasSufficientBuyingPowerForOrderResult HasSufficientBuyingPowerForOrder(
HasSufficientBuyingPowerForOrderParameters parameters
)
{
EnsureSecurityExists(parameters.Security);
var expected = SecurityModel.HasSufficientBuyingPowerForOrder(parameters);
if (reentry)
{
return(expected);
}
reentry = true;
var actual = PositionGroupModel.HasSufficientBuyingPowerForOrder(
new HasSufficientPositionGroupBuyingPowerForOrderParameters(
Portfolio,
new PositionGroup(PositionGroupModel, new Position(parameters.Security, parameters.Order.Quantity)),
parameters.Order
)
);
Assert.AreEqual(expected.IsSufficient, actual.IsSufficient,
$"{PositionGroupModel.GetType().Name}:{nameof(HasSufficientBuyingPowerForOrder)}: " +
$"ExpectedReason: {expected.Reason}{Environment.NewLine}" +
$"ActualReason: {actual.Reason}"
);
Assert.AreEqual(expected.Reason, actual.Reason,
$"{PositionGroupModel.GetType().Name}:{nameof(HasSufficientBuyingPowerForOrder)}"
);
reentry = false;
return(expected);
}
public virtual JObject GetFolders(HttpContext context)
{
YZRequest request = new YZRequest(context);
int folderid = request.GetInt32("node");
bool checkpermision = request.GetBool("checkpermision", false);
SecurityModel securitymodel = request.GetEnum <SecurityModel>("securitymodel", SecurityModel.RBAC);
bool withfolder = request.GetBool("folder", true);
bool withfile = request.GetBool("file", false);
bool iconFromExt = request.GetBool("iconFromExt", false);
bool expand = request.GetBool("expand", false);
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
using (BPMConnection bpmcn = new BPMConnection())
{
if (checkpermision && securitymodel == SecurityModel.RBAC)
{
bpmcn.WebOpen();
}
JObject rv = new JObject();
JArray items = new JArray();
rv[YZJsonProperty.children] = items;
this.ExpandTree(provider, cn, bpmcn, items, folderid, withfolder, withfile, expand, iconFromExt, checkpermision, securitymodel, true);
rv[YZJsonProperty.success] = true;
return(rv);
}
}
}
}
public void SecurityModeluserTest()
{
var model = new SecurityModel();
var first = model.tb_user.FirstOrDefault();
Assert.IsNotNull(first);
}
public async Task <IActionResult> CreateSalesOrderDetail([FromBody] SalesOrderDetailDataTransformation salesOrderDetailDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
int accountId = securityModel.AccountId;
int salesOrderId = salesOrderDetailDataTransformation.SalesOrderId;
salesOrderDetailDataTransformation.AccountId = accountId;
ResponseModel <SalesOrderDetailDataTransformation> returnResponse = new ResponseModel <SalesOrderDetailDataTransformation>();
try
{
returnResponse = await _salesOrderManagementBusinessService.CreateSalesOrderDetail(salesOrderDetailDataTransformation);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
public SecurityView(UserModel userModel, IssueModel issueModel, ProjectModel projectModel, ProjectMemberModel projectMemberModel)
: base(userModel, issueModel, projectModel, projectMemberModel)
{
InitializeComponent();
this.userModel = userModel;
this.issueModel = issueModel;
this.projectModel = projectModel;
this.projectMemberModel = projectMemberModel;
userController = new UserController(userModel);
securityController = new SecurityController(userModel);
issueController = new IssueController(userModel, issueModel, projectModel);
projectInfoController = new ProjectInfoController(projectModel);
User user = SecurityModel.getInstance().AuthenticatedUser;
usernameLabel.Text = user.UserName;
emailAddressLabel.Text = user.EmailAddress;
projectsNumberLabel.Text = projectInfoController.getAllProjectList(user.UserId).Count.ToString();
issuesNumberLabel.Text = issueController.getIssueList().Count.ToString();
usersNumberLabel.Text = securityController.listAccounts().Count.ToString();
editUsernameTextBox.Text = user.UserName;
editEmailAddressTextBox.Text = user.EmailAddress;
errorProvider = new ErrorProvider();
errorProvider.BlinkStyle = ErrorBlinkStyle.NeverBlink;
if (this.Owner == null)
{
base.logoutToolStripButton.Visible = true;
base.logoutToolStripButton.Enabled = true;
}
}
public JsonResult LogIn(string username, string password)
{
var credential =
Mocks.MockCredentials.FirstOrDefault(x =>
x.AccessCredential.Username == username);
if (credential == null)
{
return(Json(ResponseData.SendFailMsg("You are not recognized here. Please contact the Administrator"),
JsonRequestBehavior.AllowGet));
}
if (!Encryption.IsSaltEncryptValid(password, credential.AccessCredential.PasswordData,
credential.AccessCredential.PasswordSalt))
{
return(Json(
ResponseData.SendFailMsg(
"Your password is incorrect. Please try again or contact the Administrator"),
JsonRequestBehavior.AllowGet));
}
if (credential.AccessRoles.Any(x =>
x.PermissionId == (int)RolePermissions.WebAdministrator ||
x.PermissionId == (int)RolePermissions.RegOpr) == false)
{
return(Json(ResponseData.SendFailMsg("You are not authorised to use this Application"),
JsonRequestBehavior.AllowGet));
}
SecurityModel.SetUserSession(credential);
return(Json(ResponseData.SendSuccessMsg("Your credentials have been accepted. Logging you in a moment."),
JsonRequestBehavior.AllowGet));
}
private void UserInfoViewFormClosing(object sender, FormClosingEventArgs e)
{
if (this.Owner == null)
{
SecurityModel.getInstance().AuthenticatedUser = null;
}
}
public async Task <IActionResult> UpdateContact([FromBody] ContactDataTransformation contactDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
// int accountId = securityModel.AccountId;
//contactDataTransformation.AccountId = accountId;
//
ResponseModel <ContactDataTransformation> returnResponse = new ResponseModel <ContactDataTransformation>();
try
{
returnResponse = await _contactManagementBusinessService.UpdateContact(contactDataTransformation);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
public async Task <IActionResult> GetProduct([FromBody] ProductDataTransformation productDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
int accountId = securityModel.AccountId;
string productNumber = productDataTransformation.ProductNumber;
ResponseModel <ProductDataTransformation> returnResponse = new ResponseModel <ProductDataTransformation>();
try
{
returnResponse = await _salesOrderManagementBusinessService.GetProduct(accountId, productNumber);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
public ProjectApiModel UpdateProject(Project project)
{
User user = SecurityModel.getInstance().AuthenticatedUser;
ProjectApiModel model = projectModel.updateProjectInfo(user.UserId, project);
return(model);
}
public JsonResult GetAllContractModels(long facilityId)
{
SecurityModel security = new SecurityModel();
ContractModel data = new ContractModel {
UserName = security.CurrentUserName, FacilityID = facilityId
};
// Checking if the user has AllContractAccess, that mean he is a admin or super admin.
bool isCMSAccessAllContractPrivilegeFound = HasPermissions(UserInfo.Privilege.CMSAccessAllContract);
if (isCMSAccessAllContractPrivilegeFound)
{
data.UserName = null;
}
List <ContractModel> contractModels = PostApiResponse <List <ContractModel> >("ContractModel",
"GetAllContractModels", data);
List <SelectListItem> contractModelsList = new List <SelectListItem>();
if (contractModels != null && contractModels.Count > 0)
{
contractModelsList.AddRange(contractModels.Select(item => new SelectListItem
{
Text = item.NodeText,
Value = item.NodeId.ToString(CultureInfo.InvariantCulture)
}));
}
return(Json(new { contractModelList = contractModelsList }, JsonRequestBehavior.AllowGet));
}
public ProjectListView(int tabIndex, UserModel userModel, IssueModel issueModel, ProjectModel projectModel, ProjectMemberModel projectMemberModel)
: base(userModel, issueModel, projectModel, projectMemberModel)
{
InitializeComponent();
this.userModel = userModel;
this.issueModel = issueModel;
this.projectModel = projectModel;
this.projectMemberModel = projectMemberModel;
projectInfoController = new ProjectInfoController(projectModel);
projectListController = new ProjectListController(projectModel, projectMemberModel);
projectModel.projectDataChanged += updateView;
projectMemberModel.projectMemberDataChanged += updateView;
user = SecurityModel.getInstance().AuthenticatedUser;
int userId = user.UserId;
joinedProjectList = projectInfoController.getProjectListByUserId(userId);
invitedProjectList = projectInfoController.getInvitedProjectListByUserId(userId);
projectTabControl.SelectTab(tabIndex);
systemManagerTableLayoutPanel.Enabled = false;
systemManagerTableLayoutPanel.Visible = false;
generalUserTableLayoutPanel.Enabled = true;
generalUserTableLayoutPanel.Visible = true;
}
public void InitializeTabControl(TabControl control)
{
if (!project.Manager.Equals(SecurityModel.getInstance().AuthenticatedUser.UserName))
{
control.TabPages[2].Parent = null;
}
}
private void updateView()
{
userModel.updateAuthenticatedUser(user.UserId);
allProjectList = projectInfoController.getAllProjectList(user.UserId);
allProjectList.Sort(compareProjectOrder);
if (user.Authority == (int)User.AuthorityEnum.GeneralUser)
{
joinedProjectList = SecurityModel.getInstance().AuthenticatedUser.JoinedProjects;
invitedProjectList = SecurityModel.getInstance().AuthenticatedUser.InvitedProjects;
joinedProjectList.Sort(compareProjectOrder);
invitedProjectList.Sort(compareProjectOrder);
joinedProjectsDataGridView.Rows.Clear();
invitedProjectsDataGridView.Rows.Clear();
foreach (Project project in joinedProjectList)
{
joinedProjectsDataGridView.Rows.Add(new Object[] { project.ProjectId, project.ProjectName, project.Description.Replace("<br>", "; "), project.Manager });
}
foreach (Project project in invitedProjectList)
{
invitedProjectsDataGridView.Rows.Add(new Object[] { project.ProjectId, project.ProjectName, project.Description.Replace("<br>", "; "), project.Manager, "接受", "拒絕" });
}
}
else
{
allProjectsDataGridView.Rows.Clear();
foreach (Project project in allProjectList)
{
allProjectsDataGridView.Rows.Add(new Object[] { project.ProjectId, project.ProjectName, project.Description.Replace("<br>", "; "), project.Manager });
}
}
}
public async Task <IActionResult> SalesOrderInquiry([FromBody] SalesOrderInquiryDataTransformation salesOrderInquiryDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
int accountId = securityModel.AccountId;
string customerName = salesOrderInquiryDataTransformation.CustomerName;
int pageSize = salesOrderInquiryDataTransformation.PageSize;
int currentPageNumber = salesOrderInquiryDataTransformation.CurrentPageNumber;
string sortDirection = salesOrderInquiryDataTransformation.SortDirection;
string sortExpression = salesOrderInquiryDataTransformation.SortExpression;
ResponseModel <List <SalesOrderDataTransformation> > returnResponse = new ResponseModel <List <SalesOrderDataTransformation> >();
try
{
returnResponse = await _salesOrderManagementBusinessService.SalesOrderInquiry(accountId, customerName, currentPageNumber, pageSize, sortExpression, sortDirection);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
public async Task <IActionResult> SubmitSalesOrder([FromBody] SalesOrderDataTransformation salesOrderDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
int accountId = securityModel.AccountId;
salesOrderDataTransformation.AccountId = accountId;
ResponseModel <SalesOrderDataTransformation> returnResponse = new ResponseModel <SalesOrderDataTransformation>();
try
{
returnResponse = await _salesOrderManagementBusinessService.SubmitSalesOrder(salesOrderDataTransformation);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
await _messageQueueContext.Clients.All.SendAsync(MessageQueueEndpoints.SalesOrderQueue, string.Empty);
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
/// <summary>
/// Action Filter
/// </summary>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
string firstName = context.HttpContext.User.FindFirst(ClaimTypes.GivenName).Value;
string lastName = context.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
string emailAddress = context.HttpContext.User.FindFirst(ClaimTypes.Email).Value;
string companyName = context.HttpContext.User.FindFirst(ClaimTypes.Name).Value;
int userId = int.Parse(context.HttpContext.User.FindFirst(ClaimTypes.PrimarySid).Value);
int accountId = int.Parse(context.HttpContext.User.FindFirst(ClaimTypes.PrimaryGroupSid).Value);
string token = TokenManagement.CreateToken(userId, firstName, lastName, emailAddress, accountId, companyName);
SecurityModel securityModel = new SecurityModel();
securityModel.EmailAddress = emailAddress;
securityModel.FirstName = firstName;
securityModel.LastName = lastName;
securityModel.UserId = userId;
securityModel.AccountId = accountId;
securityModel.Token = token;
context.HttpContext.Items["SecurityModel"] = securityModel;
var resultContext = await next();
//context.HttpContext.Response.Headers.Add("Access-Control-Expose-Headers", "Content-Disposition");
//context.HttpContext.Response.Headers.Add("authorization", token);
}
private void logoutToolStripButtonClicked(object sender, EventArgs e)
{
SecurityModel.getInstance().AuthenticatedUser = null;
SecurityModel.getInstance().IsProgramRunning = true;
// CloseForm();
this.Close();
}
/// <summary>
/// Encrypt the text currently in the window.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void encryptCurrentWindowToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
keyForm popup = new keyForm();
popup.ShowDialog();
_currentSecurityModel = popup.getSecurityModel();
//build crypto tools based off user input
_currentCryptoTools = CryptoManager.BuildCryptoToolsFromSecurityModel(_currentSecurityModel).ToList();
popup.Dispose();
}
catch (Exception ex)
{
MessageBox.Show("Popup failed : " + ex);
InitializeSecurityObjects();
return;
}
try
{
var encryptedText = CryptoManager.RunSelectedEncryption(_currentCryptoTools, NoteTextBox1.Text, _currentSecurityModel.Password);
NoteTextBox1.Text = encryptedText;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
InitializeSecurityObjects();
return;
}
InitializeSecurityObjects();
}
public async Task <IActionResult> UpdateProduct([FromBody] ProductDataTransformation productDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
int accountId = securityModel.AccountId;
productDataTransformation.AccountId = accountId;
ResponseModel <ProductDataTransformation> returnResponse = new ResponseModel <ProductDataTransformation>();
try
{
returnResponse = await _inventoryManagementBusinessService.UpdateProduct(productDataTransformation);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
await _messageQueueContext.Clients.All.SendAsync(MessageQueueEndpoints.InventoryQueue, string.Empty);
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
public bool ValidateUser(string login, string password)
{
using (var db = new SecurityModel())
{
return db.ValidateUsers(login, password);
}
}
public void CombinedCryptoToolTest(string message, string password, bool aes, bool tdes, bool hum)
{
TestContext.WriteLine($"Params| message = {message}, password = {password}");
var sm = new SecurityModel()
{
SelectedAES = aes,
SelectedTripleDES = tdes,
SelectedHumbleCrypt = hum
};
var cryptoTools = CryptoManager.BuildCryptoToolsFromSecurityModel(sm);
var originalMessage = message;
var encrypted = CryptoManager.RunSelectedEncryption(cryptoTools, message, password);
var decrypted = CryptoManager.RunSelectedDecryption(cryptoTools, encrypted, password);
TestContext.WriteLine($"Encrypted message = {encrypted}");
TestContext.WriteLine($"Has at least one CryptoToolSelect = {aes | tdes | hum}");
if (aes | tdes | hum)
{
Assert.AreNotEqual(encrypted, decrypted);
}
Assert.AreEqual(originalMessage, decrypted);
}
public async Task <IActionResult> GetCustomer([FromBody] CustomerDataTransformation customerDataTransformation)
{
SecurityModel securityModel = (SecurityModel)(HttpContext.Items["SecurityModel"]);
int accountId = securityModel.AccountId;
int customerId = customerDataTransformation.CustomerId;
ResponseModel <CustomerDataTransformation> returnResponse = new ResponseModel <CustomerDataTransformation>();
try
{
returnResponse = await _salesOrderManagementBusinessService.GetCustomerInformation(accountId, customerId);
returnResponse.Token = securityModel.Token;
if (returnResponse.ReturnStatus == false)
{
return(BadRequest(returnResponse));
}
return(Ok(returnResponse));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
void AddCredential()
{
SecurityModel model = new SecurityModel();
model.Credential = Prompt("name of credential");
sRepository.AddCredential(model);
}
public CreateIssueView(UserModel userModel, IssueModel issueModel, ProjectModel projectModel, ProjectMemberModel projectMemberModel)
: base(userModel, issueModel, projectModel, projectMemberModel)
{
InitializeComponent();
this.userModel = userModel;
this.issueModel = issueModel;
this.projectModel = projectModel;
this.projectMemberModel = projectMemberModel;
issueController = new IssueController(userModel, issueModel, projectModel);
projectMemberController = new ProjectMemberController(projectMemberModel, userModel);
user = SecurityModel.getInstance().AuthenticatedUser;
userModel.updateAuthenticatedUser(user.UserId);
projectList = user.JoinedProjects;
foreach (Project project in projectList)
{
projectComboBox.Items.Add(project);
}
if (projectList.Count > 0)
{
projectComboBox.SelectedIndex = 0;
}
issuePriorityComboBox.SelectedIndex = 0;
issueSeverityComboBox.SelectedIndex = 0;
}
private KeyValuePair <bool, string> TryLogin()
{
string eUserName = SecurityModel.Encrypt(this.username);
string ePassword = SecurityModel.Encrypt(this.password);
KeyValuePair <bool, string> result;
var temp = _context.Client.Where(x =>
x.uname.Equals(eUserName) &&
x.upass.Equals(ePassword)).FirstOrDefault();
if (temp == null)
{
result = new KeyValuePair <bool, string>(false, "Kullanıcı bulunamadı!!!");
}
else if (temp != null && !temp.is_active)
{
result = new KeyValuePair <bool, string>(false, "Kullanıcı aktif değil!!!");
}
else if (temp != null && temp.is_delete)
{
result = new KeyValuePair <bool, string>(false, "Kullanıcı silinmiş!!!");
}
else
{
this.clientId = temp.id;
result = new KeyValuePair <bool, string>(true, "Giriş başarılı...");
}
return(result);
}
public void UpdateUserTest()
{
var context = new SecurityModel();
context.Database.CreateIfNotExists();
var repo = new CommonRepository <User, SecurityModel>(); // new Mock<IRepository<User>>();
User user = new User
{
UserName = "******",
Password = "******",
Login = "******",
CreatedDate = DateTime.Now,
IsLocked = false,
IsOnline = false
};
repo.Update(user);
//repo.Setup(r => r.Update(user));
//user.Create();
var login = context.Users.Where(u => u.UserName == "Test").Select(u => u.Login).FirstOrDefault();
Assert.AreEqual(user.Login, login);
}
public UserInfoView(UserModel userModel, IssueModel issueModel, ProjectModel projectModel, ProjectMemberModel projectMemberModel)
: base(userModel, issueModel, projectModel, projectMemberModel)
{
InitializeComponent();
this.userModel = userModel;
this.issueModel = issueModel;
this.projectModel = projectModel;
this.projectMemberModel = projectMemberModel;
userController = new UserController(userModel);
issueController = new IssueController(userModel, issueModel, projectModel);
user = SecurityModel.getInstance().AuthenticatedUser;
userModel.userDataChanged += updateView;
issueModel.issueDataChanged += updateView;
projectModel.projectDataChanged += updateView;
errorProvider = new ErrorProvider();
errorProvider.BlinkStyle = ErrorBlinkStyle.NeverBlink;
if (this.Owner == null)
{
base.logoutToolStripButton.Visible = true;
base.logoutToolStripButton.Enabled = true;
}
}
public string GetUserRoler(string login)
{
using (var db = new SecurityModel())
{
var roles = string.Join(";", db.GetUserRoles(login).Select(r => r.RoleName));
return roles;
}
}
public bool IsUserInRole(string login, string roleName)
{
using (var db = new SecurityModel())
{
var roles = db.GetUserRoles(login).Select(r => r.RoleName.ToLower(CultureInfo.InvariantCulture));
return roles.Any(r => r == roleName.ToLower(CultureInfo.InvariantCulture));
}
}
public TermGroup(string name, string description, SecurityModel securityModel, TermGroupType type)
{
_id = Guid.NewGuid();
switch (securityModel)
{
case SecurityModel.Advanced:
_name = name;
break;
case SecurityModel.Basic:
_name = _TERM_GROUP_BASIC_NAME;
break;
}
_description = description;
_type = type;
}
public void SendMessage(List<SendMessageModel> model, SecurityModel security)
{
if (security.UserName == AppSettings.UserName && security.Password == AppSettings.Password)
foreach (var item in model)
{
try
{
Bot.SendMessage(new SendMessageRequest
{
ChatId = item.ChatId,
Text = item.Message
});
}
catch (Exception e)
{
Console.Write(e.Message);
}
}
}
private void LoadSummary()
{
LoadVersion();
using (DataSet ds = Data.Template.GetTemplateSummary(_id, TemplateDef))
{
DataRow row = ds.Tables[0].Rows[0];
_name = (string)row[Data.DataNames._C_TemplateName];
_description = (string)row[Data.DataNames._C_Description];
_canGenerateDocument = bool.Parse((string)row[Data.DataNames._C_GenerateDocument]);
bool canGenerateUserDocuments;
if (bool.TryParse((string)row[Data.DataNames._C_GenerateUserDocuments], out canGenerateUserDocuments))
_canGenerateUserDocuments = canGenerateUserDocuments;
else
_canGenerateUserDocuments = false;
_status = (TemplateStatusType)((short)row[Data.DataNames._C_Status]);
_allowAttachments = bool.Parse((string)row[Data.DataNames._C_Attachments]);
bool useDetailedDescription;
if (bool.TryParse((string)row[Data.DataNames._C_UseDetailedDescription], out useDetailedDescription))
_useDetailedDescription = useDetailedDescription;
else
_useDetailedDescription = false;
bool allowComments;
if (bool.TryParse((string)row[Data.DataNames._C_AllowComments], out allowComments))
_allowComments = allowComments;
else
_allowComments = false;
try
{
_securityModel = (SecurityModel)Enum.Parse(typeof(SecurityModel), (string)row[Data.DataNames._C_SecurityModel]);
}
catch
{
_securityModel = SecurityModel.Basic;
}
try
{
_retroModel = (Retro.RetroModel)Enum.Parse(typeof(Retro.RetroModel), (string)row[Data.DataNames._C_RetroModel]);
}
catch
{
_retroModel = Retro.RetroModel.Off;
}
_systemID = (Guid)row[Data.DataNames._C_SystemID];
_summaryLoaded = true;
}
}
public static bool ValidName(string name, SecurityModel securityModel)
{
if (string.IsNullOrEmpty(name))
return false;
switch (securityModel)
{
case SecurityModel.Advanced:
return !name.Equals(_TERM_GROUP_BASIC_NAME);
case SecurityModel.Basic:
return (name.Equals(_TERM_GROUP_BASIC_NAME));
default:
return false;
}
}
public Guid AddTermGroup(string name, string description, SecurityModel securityModel, Business.TermGroup.TermGroupType termGroupType)
{
TermGroup termGroup = new TermGroup(name, description, securityModel, termGroupType);
TermGroups.Add(termGroup);
foreach (Workflow workflow in Workflows)
{
foreach (State state in workflow.States)
{
state.AddTermGroup(termGroup.ID, true);
}
}
return termGroup.ID;
}
//This call will make copies of all the pertinent pieces of the template, minimizing the need to
//extract data from the database or to perform additional parsing of the xml.
//Only those pieces deemed to be needed for Retro are initially copied over, saving additional xml parsing.
public void RetroCopy(Template sourceTemplate, bool parseEvents)
{
//Note - do not make these assignments here - they should already be defined.
//_defType
//_id
//Summary Data
_name = sourceTemplate.Name;
_status = sourceTemplate.Status;
_retroDate = sourceTemplate.RetroDate;
_templateDef = sourceTemplate.TemplateDef;
//Attributes
_systemID = sourceTemplate.SystemID;
_description = sourceTemplate.Description;
_canGenerateDocument = sourceTemplate.CanGenerateDocument;
_canGenerateUserDocuments = sourceTemplate.CanGenerateUserDocuments;
_allowComments = sourceTemplate.AllowComments;
_useDetailedDescription = sourceTemplate.UseDetailedDescription;
_securityModel = sourceTemplate.SecurityModel;
_retroModel = sourceTemplate.RetroModel;
_version = sourceTemplate.Version;
_XMLVersion = sourceTemplate.XMLVersion;
_allowAttachments = sourceTemplate.AllowAttachments;
//Collections
_basicTerms = new List<Term>(sourceTemplate.BasicTerms.Count);
foreach (Term term in sourceTemplate.BasicTerms)
_basicTerms.Add(term.RetroCopy(term.SystemTerm, this));
_complexLists = new List<Term>(sourceTemplate.ComplexLists);
_termGroups = new List<TermGroup>(sourceTemplate.TermGroups);
if (parseEvents)
{
XmlDocument xmlTemplateDoc = new XmlDocument();
xmlTemplateDoc.PreserveWhitespace = false;
xmlTemplateDoc.LoadXml(sourceTemplate.TemplateDef);
_events = Business.Events.Create(xmlTemplateDoc, this is ManagedItem);
}
else
{
_events = new List<Event>(sourceTemplate.Events);
}
_workflows = new List<Workflow>(sourceTemplate.Workflows);
//_workflows = new List<Workflow>(sourceTemplate.Workflows.Count);
//foreach (Workflow workflow in sourceTemplate.Workflows)
// _workflows.Add(workflow.Copy(workflow.Name, sourceTemplate is ManagedItem, this));
//Workflow sourceActiveworkflow = sourceTemplate.Workflows.Find(workflow => workflow.ID == sourceTemplate.ActiveWorkflowID);
//_activeWorkflowID = Workflows.Find(workflow => workflow.Name == sourceActiveworkflow.Name).ID;
//Note - Extensions not copied here, since the source may be a template and not the manageditem.
//_extensions = new List<Extension>(sourceTemplate.Extensions);
//_document = ITATDocument.Create(TemplateDef);
//_comments = new List<Comment>(sourceTemplate.Comments);
//_termDependencies = new List<TermDependency>(sourceTemplate.TermDependencies);
//_detailedDescriptions = new List<DetailedDescription>(sourceTemplate.DetailedDescriptions);
//_documentPrinters = new List<Role>(sourceTemplate.DocumentPrinters);
//Derived
//_sourceTerms = sourceTemplate.SourceTerms;
_activeWorkflowID = sourceTemplate.ActiveWorkflowID;
//_termGroupTerms = sourceTemplate.TermGroupTerms;
//Loaded indicators
_summaryLoaded = sourceTemplate._summaryLoaded;
_basicTermsLoaded = sourceTemplate._basicTermsLoaded;
_complexListsLoaded = sourceTemplate._complexListsLoaded;
_termGroupsLoaded = sourceTemplate._termGroupsLoaded;
_eventsLoaded = sourceTemplate._eventsLoaded;
_workflowLoaded = sourceTemplate._workflowLoaded;
//_msoDefined = sourceTemplate._msoDefined;
//_renewalDefined = sourceTemplate._renewalDefined;
//_extensionsLoaded = sourceTemplate._extensionsLoaded;
//_commentsLoaded = sourceTemplate._commentsLoaded;
//_documentPrintersLoaded = sourceTemplate._documentPrintersLoaded;
//_detailedDescriptionsLoaded = sourceTemplate._detailedDescriptionsLoaded;
//_termDependenciesLoaded = sourceTemplate._termDependenciesLoaded;
//_documentLoaded = sourceTemplate._documentLoaded;
}
