// NOTE: transaction has to implement or not , has to think more required.
public AdDto CreateAd(AdDto dto)
{
#region Ad
Share.Models.Ad.Entities.Ad ad = _mapper.Map <Share.Models.Ad.Entities.Ad>(dto);
ad.UserPhoneNumber = dto.UserPhoneNumber.ConvertToLongOrDefault();
ad.UserPhoneCountryCode = dto.UserPhoneCountryCode.ConvertToShortOrDefault();
int SRID = _configuration["SRID"].ConvertToInt();
ad.AddressLocation = dto.IsValidLocation ? new Point(dto.Longitude, dto.Latitude)
{
SRID = SRID
} : new Point(0.0, 0.0)
{
SRID = SRID
};
RepositoryResult result = _adRepository.Create(ad);
if (!result.Succeeded)
{
throw new Exception(string.Join(Path.PathSeparator, result.Errors));
}
#endregion
#region Google
string content = _fileReadService.ReadFile(_configuration["FolderPathForGoogleHtmlTemplate"]);
content = content.ToParseLiquidRender(dto);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(content));
string Dothtml = Path.GetExtension(_configuration["FolderPathForGoogleHtmlTemplate"]);
var bucketName = _configuration["AdBucketNameInGoogleCloudStorage"];
var objectName = string.Format("{0}{1}", dto.AttachedAssetsInCloudStorageId.Value, Dothtml);
var contentType = Utility.GetMimeTypes()[Dothtml];
_googleStorage.UploadObject(bucketName, stream, objectName, contentType);
#endregion
return(dto);
}
public async Task <RepositoryResult <KursnaListaZaDan> > NajnovijaKursnaListaAsync(CancellationToken cancellationToken)
{
var item = await _cacheService.GetAsync <KursnaListaZaDan>(KursnaListaLatestDataKey).ConfigureAwait(false);
if (item.HasValue)
{
if (cancellationToken.IsCancellationRequested)
{
return(RepositoryResult <KursnaListaZaDan> .Create(item.Value, IsCurrent(item)));
}
if (IsCurrent(item))
{
return(item.Value);
}
}
var data = await _kursnaListaDataService.GetNajnovijaKursnaListaAsync(cancellationToken).ConfigureAwait(false);
if (data != null)
{
await _cacheService.PutAsync(KursnaListaLatestDataKey, data).ConfigureAwait(false);
}
else
{
if (item.HasValue)
{
return(RepositoryResult <KursnaListaZaDan> .Create(item.Value, false));
}
}
return(data);
}
public RepositoryResult <bool> CreateQuestionAnswer(List <string> Answers)
{
try
{
var MaxAnswers = db.Answers.Count() + 1;
for (int i = 0; i < Answers.Count; i++)
{
Answer NewAnswer = new Answer();
NewAnswer.AnswerID = MaxAnswers + i;
NewAnswer.QuestionAnswer = Answers[i];
db.Answers.Add(NewAnswer);
QuestionAnswer NewQuestionAnswer = new QuestionAnswer();
NewQuestionAnswer.QuestionID = db.Questions.Count();
NewQuestionAnswer.AnswerID = NewAnswer.AnswerID;
db.QuestionAnswers.Add(NewQuestionAnswer);
}
db.SaveChanges();
return(RepositoryResult <bool> .SuccessFunc());
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(RepositoryResult <bool> .ErrorFunc());
}
}
public ServiceResult <string> DeleteRole(Guid identifier)
{
RepositoryResult <string> deleteResult = roleRepository.Delete(identifier); //błąd poprawić
//var findResult = roleRepository.Find(identifier);
return(deleteResult.IsSuccess ? ServiceResult <string> .Success("success - delete", "cs3") : ServiceResult <string> .Failed(string.Empty, "cs4"));
}
public RepositoryResult Delete(string name)
{
var result = new RepositoryResult();
try
{
var userDb = plantDb.GetCollection <UserModel>("user");
var deleteResult = userDb.DeleteOne(u => u.Name == name);
if (!deleteResult.IsAcknowledged)
{
result.Successful = false;
result.Payload = $"Cant delete user '{name}'";
}
else
{
result.Successful = true;
result.Payload = $"Successfully deleted user '{name}'";
}
}
catch (Exception e)
{
result.Successful = false;
result.Payload = e.Message;
}
return(result);
}
public RepositoryResult Register(RESTUserModel model)
{
var result = new RepositoryResult();
try
{
var userDb = plantDb.GetCollection <UserModel>("user");
var user = userDb.Find(u => u.Name == model.Username).FirstOrDefault();
if (user == null)
{
user = new UserModel();
user.Id = ObjectId.GenerateNewId().ToString();
user.Name = model.Username;
user.Password = model.Password;
userDb.InsertOne(user);
result.Successful = true;
result.Payload = $"Successfully reigstered user '{model.Username}'.";
}
else
{
result.Successful = false;
result.Payload = $"User '{model.Username}' already exists.";
}
}
catch (Exception e)
{
result.Successful = false;
result.Payload = e.Message;
}
return(result);
}
public async Task <ControllerResult> Replace(Replace model)
{
if (!ModelState.IsValid)
{
string errorMessage = string.Empty;;
foreach (ModelState modelState in ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
errorMessage = string.Format("{0}\n{1}");
}
}
ControllerResult responce = new ControllerResult()
{
IsSucces = true,
Message = string.Format("{0}/#/Replace/{1}", Repository.DNS, errorMessage)
};
RepositoryResult <ControllerResult> result = new RepositoryResult <ControllerResult>();
result.Responce = responce;
result.ResultType = RepositoryResultType.Bad;
return(result.Responce);
}
return((await this.repository.Replace(model)).Responce);
}
public RepositoryResult GetUser(string name)
{
var result = new RepositoryResult();
try
{
var userDb = plantDb.GetCollection <UserModel>("user");
var user = userDb.Find(u => u.Name == name).FirstOrDefault();
if (user == null)
{
result.Successful = false;
result.Payload = $"Cant find user '{name}'";
}
else
{
result.Successful = true;
result.Payload = user;
}
}
catch (Exception e)
{
result.Successful = false;
result.Payload = e.Message;
}
return(result);
}
public RepositoryResult <bool> RemoveQuestion(int id)
{
try
{
var RemoveQuestion = db.Questions.Find(id);
db.Questions.Remove(RemoveQuestion);
var questionAnswers = db.QuestionAnswers;
var getCurrentQuestionAnswers = questionAnswers.Where(i => i.QuestionID == id);
foreach (var answer in getCurrentQuestionAnswers)
{
db.Answers.Remove(answer.Answers);
}
db.SaveChanges();
return(RepositoryResult <bool> .SuccessFunc());
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(RepositoryResult <bool> .ErrorFunc());
}
}
/// <summary>
/// 指定したリポジトリの処理結果に適した、アクションのエラー結果を作成します。
/// </summary>
/// <typeparam name="T">コンテンツ ボディに設定するオブジェクトの型。</typeparam>
/// <param name="result">リポジトリの処理結果。</param>
/// <returns>作成されたアクションのエラー結果。</returns>
public static IActionResult CreateError <T>(RepositoryResult result)
where T : BoxResponse, new()
{
var value = BoxResponseFactory.CreateError <T>(result);
return(CreateError(result, value));
}
public ServiceResult <string> Add(FullUser user)
{
if (user == null || user.Login == null)
{
return(ServiceResult <string> .Failed(string.Empty, check_user_empty_data));
}
RepositoryResult <IEnumerable <User> > queryResult = userRepository.Query(ux => ux.Login == user.Login);
if (!queryResult.IsSuccess)
{
return(ServiceResult <string> .Failed(string.Empty, check_user_error));//tutaj error powinien przyjsc z repo
}
if (queryResult.Payload.Any())
{
return(ServiceResult <string> .Failed(string.Empty, check_user_failed));
}
RepositoryResult <User> result = userRepository.Add(user.ConverToUserRepository());
if (!result.IsSuccess)
{
return(ServiceResult <string> .Failed(string.Empty, string.Empty)); //kod od repo
}
return(ServiceResult <string> .Success("success", string.Empty)); //kod z repo o dodaniu użytkownika
}
public RepositoryResult LoginUser(RESTUserModel model)
{
var result = new RepositoryResult();
try
{
var userDb = plantDb.GetCollection <UserModel>("user");
var user = userDb.Find(u => u.Name == model.Username && u.Password == model.Password).FirstOrDefault();
if (user == null)
{
result.Successful = false;
result.Payload = $"Cant login user '{model.Username}'";
}
else
{
result.Successful = true;
result.Payload = $"Successfully logged in user '{model.Username}'";
}
}
catch (Exception e)
{
result.Successful = false;
result.Payload = e.Message;
}
return(result);
}
public RepositoryResult <Question> GetNextQuestion(Question question, string id)
{
try
{
if (id == "Skipped")
{
TempClass.NextQuestionNumber++;
TempClass.TotallyAnsweredQuestions++;
}
var Question = NextQuetion(question.ID, question.TestName, question.DifficultyLevel, question.UserName);
if (Question != null)
{
return(RepositoryResult <Question> .SuccessFunc("", Question));
}
else
{
return(RepositoryResult <Question> .ErrorFunc());
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(null);
}
/// <summary>
/// Creates the container if it does not yet exist in the storage account
/// </summary>
/// <param name="container"></param>
/// <returns></returns>
public async Task <RepositoryResult> EnsureContainerCreated(string container)
{
await _blobClient.GetBlobContainerClient(container)
.CreateIfNotExistsAsync();
return(RepositoryResult.Success());
}
public RepositoryResult <bool> EditQuestion(Question question, List <string> InputAnswers)
{
try
{
db.Entry(question).State = EntityState.Modified;
db.SaveChanges();
var getQuestion = db.QuestionAnswers;
var getCurrentQuestionAnswers = getQuestion.Where(i => i.QuestionID == question.ID);
int Counter = 0;
foreach (var realAnswer in getCurrentQuestionAnswers)
{
Answer RealAnswer = realAnswer.Answers;
RealAnswer.QuestionAnswer = InputAnswers[Counter];
Counter++;
db.Entry(RealAnswer).State = EntityState.Modified;
}
db.SaveChanges();
return(RepositoryResult <bool> .SuccessFunc());
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(RepositoryResult <bool> .ErrorFunc());
}
}
//select
public virtual async Task <TotalResult <List <SignalBounce <long> > > > SelectPage(
int pageIndex, int pageSize, List <long> receiverSubscriberIds = null)
{
RepositoryResult <SignalBounceLong> response = null;
using (Repository repository = new Repository(_dbContextFactory.GetDbContext()))
{
Expression <Func <SignalBounceLong, bool> > where = x => true;
if (receiverSubscriberIds != null)
{
where = x => x.ReceiverSubscriberId != null &&
receiverSubscriberIds.Contains(x.ReceiverSubscriberId.Value);
}
response = await repository.FindPageAsync(pageIndex, pageSize, true,
where, x => x.SignalBounceId, true)
.ConfigureAwait(false);
}
List <SignalBounce <long> > mappedItems = response.Data
.Select(_mapper.Map <SignalBounce <long> >)
.ToList();
return(new TotalResult <List <SignalBounce <long> > >(mappedItems, response.TotalRows));
}
public async Task <ControllerResult> SignIn(SignIn model)
{
RepositoryResult <ControllerResult> result = new RepositoryResult <ControllerResult>();
RepositoryResult <User, ControllerResult> repoResult = await this.repository.SignIn(model);
result.Responce = repoResult.Responce;
if (repoResult.Value == null)
{
return(result.Responce);
}
else
{
ClaimsIdentity claim = await UserManager.CreateIdentityAsync(repoResult.Value,
DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
return(result.Responce);
}
}
public async Task <ControllerResult> SignUp(SignUp model)
{
if (!ModelState.IsValid)
{
string errorMessage = string.Empty;
foreach (ModelState modelState in ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
errorMessage = string.Format("{0}\n{1}", errorMessage, error.ErrorMessage);
}
}
ControllerResult responce = new ControllerResult()
{
IsSucces = true,
Message = string.Format("{0}/#/SignUp/{1}", Repository.DNS, errorMessage)
};
return(responce);
}
NotActiveUser user = new NotActiveUser(model);
RepositoryResult <ControllerResult> result = await this.repository.RegistartionAsync(user);
return(result.Responce);
}
/// <summary>
/// 指定したリポジトリの処理結果に適した、BOX レスポンスを作成します。
/// </summary>
/// <typeparam name="T">コンテンツ ボディに設定するオブジェクトの型。</typeparam>
/// <param name="result">リポジトリの処理結果。</param>
/// <returns>作成された BOX レスポンス。</returns>
public static T CreateError <T>(RepositoryResult result)
where T : BoxResponse, new()
{
return(new T
{
ErrorMessage = result.ErrorMessage
});
}
public ServiceResult <FullUser> Update(FullUser user)
{
RepositoryResult <User> updateResult = userRepository.Update(user.ConverToUserRepository());
return(updateResult.IsSuccess ?
ServiceResult <FullUser> .Success(updateResult.Payload.ConverToFullUser(), updateResult.Code) :
ServiceResult <FullUser> .Failed(null, updateResult.Code));
}
public ServiceResult <UserServiceModel> Get(Guid identifer)
{
RepositoryResult <User> findResult = userRepository.Find(identifer);
return(findResult.IsSuccess ?
ServiceResult <UserServiceModel> .Success(findResult.Payload.ConverToUserService(), findResult.Code) :
ServiceResult <UserServiceModel> .Failed(new UserServiceModel(), findResult.Code));
}
public ServiceResult <string> Delete(Guid identifier)
{
RepositoryResult <string> deleteResult = userRepository.Delete(identifier);
return(deleteResult.IsSuccess ?
ServiceResult <string> .Success(deleteResult.Payload, deleteResult.Code) :
ServiceResult <string> .Failed(deleteResult.Payload, deleteResult.Code));
}
/// <summary>
/// Checks if the file exists
/// </summary>
/// <param name="fileDate"></param>
/// <param name="container"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public Task <RepositoryResult <bool> > CheckIfFileExistsAsync(DateTime fileDate, string container, string fileName)
{
var fileExists = _savedFiles
.Any(f => f.Container == container &&
f.FileName == fileName);
return(Task.FromResult(RepositoryResult <bool> .Success(fileExists)));
}
public async Task <HttpResponseMessage> CancelReplace(Guid replaceCode)
{
logger.WriteInformation(string.Format("Отмена запроса на смена пароля пользователя с кодом подтверждения {0}", replaceCode));
RepositoryResult <HttpResponseMessage> result = await this.repository.CancelReplace(replaceCode);
return(result.Responce);
}
public void ReturnsSuccessOnSuccess()
{
var result = RepositoryResult <string> .Success("Hello");
Assert.True(result.IsSuccess);
Assert.Null(result.ErrorMessage);
Assert.Equal("Hello", result.Value);
}
public Task <RepositoryResult <Academy> > GetAcademyByUkprn(string ukprn)
{
var academy = new Academy
{
Ukprn = ukprn,
Performance = new AcademyPerformance
{
SchoolPhase = "Placeholder",
AgeRange = "Placeholder",
Capacity = "Placeholder",
Nor = "Placeholder",
Pan = "Placeholder",
Pfi = "Placeholder",
ViabilityIssue = "Placeholder",
Deficit = "Placeholder",
SchoolType = "Placeholder",
DiocesesPercent = "Placeholder",
DistanceToSponsorHq = "Placeholder",
MpAndParty = "Placeholder",
OfstedJudgementDate = "Placeholder",
CurrentFramework = "Placeholder",
AchievementOfPupil = "Placeholder",
QualityOfTeaching = "Placeholder",
BehaviourAndSafetyOfPupil = "Placeholder",
LeadershipAndManagement = "Placeholder"
},
PupilNumbers = new PupilNumbers
{
GirlsOnRoll = "Placeholder",
BoysOnRoll = "Placeholder",
WithStatementOfSen = "Placeholder",
WhoseFirstLanguageIsNotEnglish = "Placeholder",
EligibleForFreeSchoolMeals = "Placeholder"
},
LatestOfstedJudgement = new LatestOfstedJudgement
{
AchievementOfPupils = "Placeholder",
BehaviourAndSafetyOfPupils = "Placeholder",
EarlyYearsProvision = "Placeholder",
Effectiveness = "Placeholder",
InspectionDate = "Placeholder",
LeadershipAndManagement = "Placeholder",
QualityOfTeaching = "Placeholder",
SchoolName = "Placeholder"
}
};
var result = new RepositoryResult <Academy>()
{
Result = academy
};
return(Task.FromResult(result));
}
protected async Task <RepositoryResult <T> > LoadFromCacheThenRefreshAsync <T>(
string key,
DateTime?updatedTime,
Func <T, DateTime> updatedTimeFunc,
TimeSpan staleAfter,
TimeSpan expireAfter,
Func <Task <ServiceResult <T> > > getDataFuncAsync,
Func <RepositoryResult <T>, Task> refreshActionAsync = null
)
{
try
{
var useUpdatedTime = updatedTime != null;
var cacheItem = useUpdatedTime
? await _cacheService.GetAsync <T>(key, updatedTime.Value)
: await _cacheService.GetAsync <T>(key);
if (cacheItem.HasValue &&
!cacheItem.IsStale &&
!cacheItem.IsExpired)
{
return(RepositoryResult <T> .Create(cacheItem.Value));
}
if (cacheItem.HasValue &&
cacheItem.IsStale &&
!cacheItem.IsExpired &&
refreshActionAsync != null)
{
refreshActionAsync(RepositoryResult <T> .Create(cacheItem.Value, false));
}
var serviceResult = await getDataFuncAsync().ConfigureAwait(false);
if (serviceResult.Successful)
{
if (useUpdatedTime)
{
// ReSharper disable once CSharpWarnings::CS4014, no need to wait storage operation
_cacheService.PutAsync(key, updatedTimeFunc(serviceResult.Value), serviceResult.Value,
DateTime.Now + staleAfter, DateTime.Now + expireAfter);
}
else
{
// ReSharper disable once CSharpWarnings::CS4014, no need to wait storage operation
_cacheService.PutAsync(key, serviceResult.Value,
DateTime.Now + staleAfter, DateTime.Now + expireAfter);
}
}
return(serviceResult);
}
catch (Exception xcp)
{
return(RepositoryResult <T> .CreateError(xcp));
}
}
public HttpResponseMessage CreateUserWifi(UserMacAddressDetails objUserMac)
{
StatusReturn objReturn = null;
if (!ModelState.IsValid)
{
var response = Request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
return(response);
}
try
{
RepositoryResult repResult = UserRepository.CreateWifiUser(objUserMac.objUser);
if (repResult == RepositoryResult.Success)
{
repResult = UserRepository.CreateUserRole(objUserMac.objUser);
if (repResult == RepositoryResult.Success)
{
objUserMac.objMacAddress.UserId = objUserMac.objUser.Id;
repResult = MacAddressRepository.CreateNewMacDevice(objUserMac.objMacAddress);
if (repResult == RepositoryResult.Success)
{
objUserMac.objAddress.UserId = objUserMac.objUser.Id;
repResult = UserAddressRepository.CreateUserAddress(objUserMac.objAddress);
if (repResult == RepositoryResult.Success)
{
//objRegisterDB.CreateNewUser(objUserMac.objUser.UserName, objUserMac.objUser.PasswordHash, objUserMac.objUser.Email, objUserMac.objUser.FirstName, objUserMac.objUser.LastName);
if (UserRepository.IsMemeber(objUserMac.objUser.UserName) && MacAddressRepository.IsMacAddressExistInParticularSite(objUserMac.objMacAddress.MacAddressValue, (int)objUserMac.objUser.SiteId))
{
using (CommunicateRTLS objCommunicateRtls = new CommunicateRTLS())
{
string retResult = objCommunicateRtls.RegisterInRealTimeLocationService(new[] { objUserMac.objMacAddress.MacAddressValue }).Result;
Notification objServiceReturn = JsonConvert.DeserializeObject <Notification>(retResult);
if (objServiceReturn.result.returncode == Convert.ToInt32(RTLSResult.Success))
{
MacAddressRepository.RegisterMacAddressToRtls(objUserMac.objMacAddress.MacAddressValue);
}
}
}
}
}
}
objReturn = new StatusReturn(Convert.ToInt32(ReturnCode.Success), ReturnCode.Success.ToString(), Common.Common.Reg_Success);
//dbContextTransaction.Commit();
}
}
catch (Exception ex)
{
//dbContextTransaction.Rollback();
objReturn = new StatusReturn(Convert.ToInt32(ReturnCode.Failure), ReturnCode.Success.ToString(), Common.Common.Reg_Success);
}
return(new HttpResponseMessage()
{
Content = new StringContent(JsonConvert.SerializeObject(objReturn), Encoding.UTF8, "application/json")
});
}
private ArticleDto InsertArticle(ArticleDto dto)
{
Share.Models.Article.Entities.Article article = _mapper.Map <Share.Models.Article.Entities.Article>(dto);
RepositoryResult result = _articleRepository.Create(article);
if (!result.Succeeded)
{
throw new Exception(string.Join(",", result.Errors));
}
return(dto);
}
/// <summary>
/// Deletes the file
/// </summary>
/// <param name="fileDate"></param>
/// <param name="container"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public Task <RepositoryResult> DeleteFileAsync(DateTime fileDate, string container, string fileName)
{
var file = _savedFiles.FirstOrDefault(f => f.Container == container &&
f.FileName == fileName);
if (file != null)
{
_savedFiles.Remove(file);
}
return(Task.FromResult(RepositoryResult.Success()));
}
public SaveActivitiesViewModel(RepositoryResult result)
{
ShowLoginContol = result is FailureResult;
Message = result.Message;
}
