public async Task <IActionResult> Register([FromBody] UserCredentials credentials)
{
if (!ModelState.IsValid)
{
return(ErrorHelper.Error(ModelState));
}
var user = new UserContractModel {
UserName = credentials.Email, Email = credentials.Email
};
var result = await _userManager.CreateAsync(user, credentials.Password);
if (!result.Succeeded)
{
return(ErrorHelper.Error(result));
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
_emailSender.SendEmailConfirmationAsync(credentials.Email, callbackUrl);
result = await _userManager.AddToRoleAsync(user, _defaultRole.Role);
if (!result.Succeeded)
{
return(ErrorHelper.Error(result));
}
return(Ok("Account confirmation is required."));
}
public HttpResponseMessage UploadDocument(DocumentContractModel document)
{
UserContractModel user = GetUser();
if (!string.IsNullOrEmpty(user.Username) && user.Admin)
{
try
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
document.Username = user.Username;
business.UploadDocument(document);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (BusinessException ex)
{
logger.Error(ex.Message);
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex));
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
public HttpResponseMessage Post(UserContractModel userContractModel)
{
try
{
var re = Request;
var header = re.Headers;
if (header.Contains("Username"))
{
if (header.Contains("Admin"))
{
string value = header.GetValues("Admin").First();
userContractModel.Admin = value == "1";
}
if (string.IsNullOrEmpty(header.GetValues("Username").First()))
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
return(Request.CreateResponse(HttpStatusCode.OK, userContractModel));
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
}
private UserContractModel GetUser()
{
UserContractModel user = new UserContractModel();
var re = Request;
var header = re.Headers;
if (header.Contains("Username"))
{
if (header.Contains("Admin"))
{
string value = header.GetValues("Admin").First();
user.Admin = value == "1";
}
user.Username = header.GetValues("Username").First();
return(user);
}
return(user);
}
public HttpResponseMessage GetDocuments()
{
UserContractModel user = GetUser();
if (!string.IsNullOrEmpty(user.Username))
{
try
{
IQueryable <DocumentContractModel> documents = business.GetDocuments();
return(Request.CreateResponse(HttpStatusCode.OK, documents));
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
public bool CheckConfirmation(UserContractModel user)
{
return(false);
}
public void Login(UserContractModel contractModel)
{
throw new NotImplementedException();
}
public UserContractModel RegisterUser(UserContractModel contractModel)
{
throw new NotImplementedException();
}
public void Initialize(OnlineMarketContext context, RoleManager <IdentityRole> roleManager, UserManager <UserContractModel> userManager, IOptions <UserSettingsOptions> userSettings, IOptions <DefaultUserRolesOptions> roles)
{
context.Database.EnsureCreated();
if (context.ItemTypes.Any())
{
return;
}
//Trying staff until it works
foreach (var x in roles.Value.Roles)
{
var roleExist = roleManager.RoleExistsAsync(x).Result;
if (roleExist)
{
continue;
}
var unused = roleManager.CreateAsync(new IdentityRole(x)).Result;
}
var user = new UserContractModel
{
UserName = userSettings.Value.UserName,
Email = userSettings.Value.UserEmail,
EmailConfirmed = true
};
var createAdminUser = userManager.CreateAsync(user, userSettings.Value.UserPassword).Result;
if (createAdminUser.Succeeded)
{
var unused = userManager.AddToRoleAsync(user, userSettings.Value.UserRole).Result;
}
var store = new StoreDataModel {
Name = "testStore"
};
context.Store.Add(store);
context.SaveChanges();
var accounts = new List <AccountDataModel>()
{
new AccountDataModel {
AccountOwnerId = user.Id, AvailableBalance = 10000
},
new AccountDataModel {
AccountOwnerId = store.Id, AvailableBalance = 1000000
}
};
context.Accounts.AddRange(accounts);
context.SaveChanges();
var itemTypes = new List <ItemTypeDataModel>
{
new ItemTypeDataModel {
Name = "Oil"
},
new ItemTypeDataModel {
Name = "Iron"
},
new ItemTypeDataModel {
Name = "Wood"
}
};
context.ItemTypes.AddRange(itemTypes);
context.SaveChanges();
var storage = new List <StorageDataModel>();
var exchangeRates = new List <ExchangeRatesDataModel>();
itemTypes.ForEach(x =>
{
exchangeRates.Add(new ExchangeRatesDataModel {
Rate = 15, ItemType = x, ItemTypeId = x.Id
});
storage.Add(new StorageDataModel {
ItemTypeId = x.Id, ItemType = x, Account = accounts.First(), AccountId = accounts.First().Id, Quantity = 0, StorageAmount = 0
});
storage.Add(new StorageDataModel {
ItemTypeId = x.Id, ItemType = x, Account = accounts.Last(), AccountId = accounts.Last().Id, Quantity = 1000, StorageAmount = 15 * 1000
});
});
context.Storages.AddRange(storage);
context.CurrentRates.AddRange(exchangeRates.Select(x => new CurrentRateDataModel
{
ItemType = x.ItemType,
Rate = x.Rate,
ItemTypeId = x.ItemTypeId
}));
context.ExchangeRates.AddRange(exchangeRates);
context.SaveChanges();
}
