public async Task <OrganisationServiceModel> CreateAsync(CreateOrganisationServiceModel serviceModel)
        {
            var existingOrganisation = await this.identityContext.Organisations.FirstOrDefaultAsync(x => x.ContactEmail == serviceModel.Email && x.IsActive);

            if (existingOrganisation != null)
            {
                throw new CustomException(this.globalLocalizer.GetString("OrganisationExistsAlready"), (int)HttpStatusCode.Conflict);
            }

            var organisation = new Organisation
            {
                Name         = serviceModel.Name,
                ContactEmail = serviceModel.Email,
                IsSeller     = false,
                Domain       = new MailAddress(serviceModel.Email).Host,
                Key          = new MailAddress(serviceModel.Email).Host.Split('.')[0],
                Language     = serviceModel.CommunicationsLanguage
            };

            this.identityContext.Organisations.Add(organisation.FillCommonProperties());

            await this.identityContext.SaveChangesAsync();

            return(await this.GetAsync(new GetOrganisationModel { Email = serviceModel.Email, Language = serviceModel.Language, OrganisationId = serviceModel.OrganisationId, Username = serviceModel.Username }));
        }
Example #2
0
        public async Task <IActionResult> Save([FromBody] OrganisationRequestModel request)
        {
            var sellerClaim = this.User.Claims.FirstOrDefault(x => x.Type == AccountConstants.Claims.OrganisationIdClaim);

            if (!request.Id.HasValue)
            {
                var serviceModel = new CreateOrganisationServiceModel
                {
                    Name  = request.Name,
                    Email = request.Email,
                    CommunicationsLanguage = request.CommunicationLanguage,
                    Language       = CultureInfo.CurrentCulture.Name,
                    Username       = this.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value,
                    OrganisationId = GuidHelper.ParseNullable(sellerClaim?.Value)
                };

                var validator = new CreateOrganisationModelValidator();

                var validationResult = await validator.ValidateAsync(serviceModel);

                if (validationResult.IsValid)
                {
                    var organisation = await this.organisationService.CreateAsync(serviceModel);

                    if (organisation != null)
                    {
                        var response = new OrganisationResponseModel
                        {
                            Id          = organisation.Id,
                            Description = organisation.Description,
                            Name        = organisation.Name,
                            Files       = organisation.Files,
                            Images      = organisation.Images,
                            Videos      = organisation.Videos
                        };

                        return(this.StatusCode((int)HttpStatusCode.Created, response));
                    }
                }

                throw new CustomException(string.Join(ErrorConstants.ErrorMessagesSeparator, validationResult.Errors.Select(x => x.ErrorMessage)), (int)HttpStatusCode.UnprocessableEntity);
            }

            return(this.StatusCode((int)HttpStatusCode.BadRequest));
        }