gem install cocoapods

pod init
pod install

platform :ios, '11.0'

target 'Avitogram' do
  use_frameworks!

	#core
	pod 'Swinject', :git => 'https://github.com/Swinject/Swinject.git'
        pod ‘PluggableAppDelegate’
        
        #firebase services
        pod 'Firebase/Analytics'
	
	#ui
	pod 'EasyPeasy'

end

gem install generamba
generamba setup

$ generamba setup
The company name which will be used in the headers: Proglib
The name of your project is Avitogram. Do you want to use it? (yes/no) yes
The project prefix (if any): 
The path to a .xcodeproj file of the project is 'Avitogram.xcodeproj'. Do you want to use it? (yes/no) yes
Select the appropriate target for adding your MODULES (type the index):
gramvito 
1. AvitogramTests
2. AvitogramUITests 

Are you using unit-tests in this project? (yes/no) 
Do you want to add all your modules by one path? (yes/no) yes
Do you want to use the same paths for your files both in Xcode and the filesystem? (yes/no) 
The default path for creating new modules (in Xcode groups): Avitogram/Source/Modules
The default path for creating new modules (in the filesystem): Avitogram/Source/Modules
Are you using Cocoapods? (yes/no) yes
The path to a Podfile is 'Podfile'. Do you want to use it? (yes/no) yes
Are you using Carthage? (yes/no) no
Do you want to add some well known templates to the Rambafile? (yes/no) no

### Headers settings
company: Proglib

### Xcode project settings
project_name: Avitogram
xcodeproj_path: Avitogram.xcodeproj

### Code generation settings section
# The main project target name
project_target: Avitogram

# The file path for new modules
project_file_path: Avitogram/Source/Modules

# The Xcode group path to new modules
project_group_path: Avitogram/Source/Modules

### Dependencies settings section
podfile_path: Podfile

### Templates
templates:
#- {name: local_template_name, local: 'absolute/file/path'}
#- {name: remote_template_name, git: 'https://github.com/igrekde/remote_template'}
#- {name: catalog_template_name}

templates:
- {name: swifty_mvp, git: 'https://github.com/spase84/swift_mvp'}

generamba template install

generamba gen Guest swifty_mvp

import UIKit
import PluggableAppDelegate

@UIApplicationMain
class AppDelegate: PluggableApplicationDelegate {
	
	private var rootApplicationService = RootApplicationService()
	
	override var services: [ApplicationService] {
		return [
			rootApplicationService,
			GoogleApplicationService()
		]
	}
	
	func reloadRootScreen() {
		rootApplicationService.reloadStartScreen()
	}
}

import Foundation
import PluggableAppDelegate
import Swinject

final class RootApplicationService: NSObject, ApplicationService {
	
	private var application: UIApplication!
	private let assembler = Assembler([])
	private let assemblies: [Assembly] = [
		GuestAssembly()
	]

	func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
		self.application = application
		assembler.apply(assemblies: assemblies)
		self.reloadStartScreen()
		return true
	}

	public func reloadStartScreen() {
		DispatchQueue.main.async {
			if UserServiceImpl.currentUser.isGuest ||
				UserServiceImpl.isFirstLaunch {
				self.load(moduleType: .guest, for: self.application)
			} else {
				self.load(moduleType: .home, for: self.application)
			}
		}
	}

	// MARK: - private
	private enum LoadingModuleType {
		case guest, home
	}

	private func load(moduleType: LoadingModuleType, for application: UIApplication) {
		var rootVC = UIViewController()
		rootVC.view.backgroundColor = .SLBlack
		switch moduleType {
		case .home:
			if let vc = assembler.resolver.resolve(HomeViewType.self) as? HomeViewController {
				let navigation = UINavigationController(rootViewController: vc)
				navigation.navigationBar.tintColor = .white
				navigation.navigationBar.barTintColor = .SLBlackTwo
				navigation.navigationBar.titleTextAttributes = [.foregroundColor: UIColor.white]
				rootVC = navigation
			}
		case .guest:
			if let vc = assembler.resolver.resolve(GuestViewType.self) as? GuestViewController {
				rootVC = vc
			}
		}

		UserServiceImpl.isFirstLaunch = false

		if let delegate = application.delegate as? AppDelegate {
			if nil == delegate.window { delegate.window = UIWindow() }
			delegate.window?.rootViewController = rootVC
			delegate.window?.makeKeyAndVisible()
		}
	}
}

protocol UserService {
	var trigger: PublishSubject<(AuthStatus, Error?)> { get }
	static var currentUser: User { get }
	static var isFirstLaunch: Bool { get set }
	func signIn(email: String, password: String)
	func signUp(email: String, password: String)
	func signOut()
}

import Foundation
import PluggableAppDelegate
import Swinject

final class RootApplicationService: NSObject, ApplicationService {
	
	private var application: UIApplication!
	private let assembler = Assembler([])
	private let assemblies: [Assembly] = [
		ServicesAssembly(),
		GuestAssembly()
	]

	func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
		self.application = application
		assembler.apply(assemblies: assemblies)
		self.reloadStartScreen()
		return true
	}

	public func reloadStartScreen() {
		DispatchQueue.main.async {
			self.load(moduleType: .guest, for: self.application)
		}
	}

	// MARK: - private

	private enum LoadingModuleType {
		case guest
	}

	private func load(moduleType: LoadingModuleType, for application: UIApplication) {
		var rootVC = UIViewController()
		rootVC.view.backgroundColor = .SLBlack
		switch moduleType {
		case .guest:
			if let vc = assembler.resolver.resolve(GuestViewType.self) as? GuestViewController {
				rootVC = vc
			}
		}

		if let delegate = application.delegate as? AppDelegate {
			if nil == delegate.window { delegate.window = UIWindow()                 }
			delegate.window?.rootViewController = rootVC
			delegate.window?.makeKeyAndVisible()
		}
	}
}

final class UserServiceImpl: UserService {
	private(set) var trigger: PublishSubject<(AuthStatus, Error?)> = PublishSubject<(AuthStatus, Error?)>()
	private let firebaseAuth = Auth.auth()
	static var currentUser: User {
		var user = User()
		if let firUser = Auth.auth().currentUser {
			user.id = firUser.uid
			user.name = firUser.displayName
		}
		return user
	}
	static var isFirstLaunch: Bool {
		get {
			return !UserDefaults.standard.bool(forKey: "isNotFirstLaunch")
		}
		set {
			UserDefaults.standard.set(!newValue, forKey: "isNotFirstLaunch")
			UserDefaults.standard.synchronize()
		}
	}

	func signIn(email: String, password: String) {
		firebaseAuth.signIn(withEmail: email, password: password) { [weak self] authResult, error in
			if let error = error {
				self?.trigger.onNext((.guest, error))
			} else {
				switch authResult {
				case .some:
					self?.trigger.onNext((.authorized, nil))
				default:
					break
				}
			}
		}
	}
	
	func signUp(email: String, password: String) {
		firebaseAuth.createUser(withEmail: email, password: password) { [weak self] authResult, error in
			if let error = error {
				self?.trigger.onNext((.guest, error))
			} else {
				switch authResult {
				case .some:
					self?.trigger.onNext((.authorized, nil))
				default:
					break
				}
			}
		}
	}
	
	func signOut() {
		do {
			try firebaseAuth.signOut()
		} catch let signOutError as NSError {
			debugPrint("Error signing out: %@", signOutError.localizedDescription)
		}
	}
}

struct User {

            var id: String?
            var name: String?
            var isGuest: Bool { nil == id }

}

import Foundation
import Firebase
import RxSwift

enum AuthStatus {
	case guest, authorized
}

protocol UserService {
	var trigger: PublishSubject<(AuthStatus, Error?)> { get }
	static var currentUser: User { get }
	static var isFirstLaunch: Bool { get set }
	func signIn(email: String, password: String)
	func signUp(email: String, password: String)
	func signOut()
}

final class UserServiceImpl: UserService {
	private(set) var trigger: PublishSubject<(AuthStatus, Error?)> = PublishSubject<(AuthStatus, Error?)>()
	private let firebaseAuth = Auth.auth()
	static var currentUser: User {
		var user = User()
		if let firUser = Auth.auth().currentUser {
			user.id = firUser.uid
			user.name = firUser.displayName
		}
		return user
	}
	static var isFirstLaunch: Bool {
		get {
			return !UserDefaults.standard.bool(forKey: "isNotFirstLaunch")
		}
		set {
			UserDefaults.standard.set(!newValue, forKey: "isNotFirstLaunch")
			UserDefaults.standard.synchronize()
		}
	}

	func signIn(email: String, password: String) {
		firebaseAuth.signIn(withEmail: email, password: password) { [weak self] authResult, error in
			if let error = error {
				self?.trigger.onNext((.guest, error))
			} else {
				switch authResult {
				case .some:
					self?.trigger.onNext((.authorized, nil))
				default:
					break
				}
			}
		}
	}
	
	func signUp(email: String, password: String) {
		firebaseAuth.createUser(withEmail: email, password: password) { [weak self] authResult, error in
			if let error = error {
				self?.trigger.onNext((.guest, error))
			} else {
				switch authResult {
				case .some:
					self?.trigger.onNext((.authorized, nil))
				default:
					break
				}
			}
		}
	}
	
	func signOut() {
		do {
			try firebaseAuth.signOut()
		} catch let signOutError as NSError {
			debugPrint("Error signing out: %@", signOutError.localizedDescription)
		}
	}
}

generamba gen Home swifty_mvp

private let tableView: UITableView = {
		let table = UITableView()
		table.register(PostCell.self, forCellReuseIdentifier: PostCell.identifier)
		table.separatorStyle = .none
		table.backgroundColor = .clear
		table.tableFooterView = UIView()
		table.showsVerticalScrollIndicator = false
		table.showsHorizontalScrollIndicator = false
		return table
	}()

	private let refresher: UIRefreshControl = {
		let refreshControl = UIRefreshControl()
		refreshControl.tintColor = .SLDullYellow
		return refreshControl
	}()

struct Post {
	var title: String = ""
	var createdAt: Date = Date()
	var userId: String?
	var imageName: String?

	var image: ImageSource?
	var reference: StorageReference?

	enum Fields: String {
		case id = "id"
		case createdAt = "created_at"
		case userId = "user_id"
		case imageName = "image_name"
	}

	enum ValidationError: Error {
		case titleEmpty
		case imageEmpty
		case userIdEmpty
		
		var localizedDescription: String {
			switch self {
			case .titleEmpty:
				return "error_create_post_empty_title".localized.firstUppercased
			case .imageEmpty:
				return "error_create_post_empty_image".localized.firstUppercased
			case .userIdEmpty:
				return "error_create_post_empty_user".localized.firstUppercased
			}
		}
	}
}

extension Post: Codable {
	private enum CodingKeys: String, CodingKey {
		case title
		case createdAt = "created_at"
		case userId = "user_id"
		case imageName = "image_name"
	}
}

private let data = PublishSubject<[Post]>()

private func bindTable() {
		data.bind(to: tableView.rx.items(cellIdentifier: PostCell.identifier, cellType: PostCell.self)) { _, post, cell in
			cell.value = post
		}.disposed(by: disposeBag)
	}

final class PostCell: BaseTableViewCell {
	override var value: Any? {
		didSet {
			guard let post = value as? Post else { return }
			fillUI(post: post)
		}
	}

	// MARK: - subviews
	private let gradient = CAGradientLayer()

	private var indicator: UIActivityIndicatorView = {
		let view = UIActivityIndicatorView(style: .whiteLarge)
		view.color = .SLBlackTwo
		view.startAnimating()
		return view
	}()

	private var imgView: UIImageView = {
		let view = UIImageView()
		view.contentMode = .scaleAspectFill
		view.backgroundColor = UIColor.lightGray.withAlphaComponent(0.7)
		view.clipsToBounds = true
		view.layer.cornerRadius = 4
		return view
	}()

	private let titleLabel: UILabel = {
		let label = UILabel()
		label.textColor = .white
		label.font = UIFont.systemFont(ofSize: 17, weight: .bold)
		label.numberOfLines = 0
		label.lineBreakMode = .byWordWrapping
		return label
	}()

	private let dateLabel: UILabel = {
		let label = UILabel()
		label.textColor = UIColor.white.withAlphaComponent(0.8)
		label.font = UIFont.systemFont(ofSize: 13)
		label.textAlignment = .right
		return label
	}()

	override func configure() {
		super.configure()
		addSubview(imgView)
		addSubview(titleLabel)
		addSubview(dateLabel)
		imgView.easy.layout(Left(8), Right(8), Top(16), Height().like(imgView, .width), Bottom())
		titleLabel.easy.layout(Left(16), Bottom(16).to(imgView, .bottom), Height(>=20).with(.required))
		dateLabel.easy.layout(Left(10).to(titleLabel, .right), Top(10).to(bottom, .imgView), Height(20), Right(16), Bottom(16).to(imgView, .bottom))
		imgView.addSubview(indicator)
		indicator.easy.layout(Center())
	}

	// MARK: - private
	private func fillUI(post: Post) {
		titleLabel.text = post.title
		if Calendar.current.isDateInToday(post.createdAt) {
			dateLabel.text = post.createdAt.hh．mm
		} else {
			dateLabel.text = post.createdAt.dd．MM．yy
		}
		guard let reference = post.reference else { return }
		imgView.sd_setImage(with: reference, placeholderImage: nil) { [weak self] _, _, _, _ in
			self?.indicator.stopAnimating()
			
			guard let gradient = self?.gradient else { return }
			gradient.removeFromSuperlayer()

			gradient.frame = self?.imgView.frame ?? .zero
			gradient.position.x -= 8
			gradient.colors = [
					UIColor(white: 0, alpha: 0).cgColor,
					UIColor(white: 0, alpha: 0).cgColor,
					UIColor(white: 0, alpha: 0.6).cgColor
			]
			self?.imgView.layer.insertSublayer(gradient, at: 0)
		}
	}
}

generamba gen CreatePost swifty_mvp

import UIKit
import EasyPeasy
import ImageSource

protocol CreatePostViewDelegate: class {
	func titleUpdated(text: String)
}

final class CreatePostView: BaseView {
	private weak var delegate: CreatePostViewDelegate?

	// subviews
	private let imageView: UIImageView = {
		let view = UIImageView()
		view.contentMode = .scaleAspectFill
		view.backgroundColor = UIColor.lightGray.withAlphaComponent(0.2)
		view.clipsToBounds = true
		return view
	}()

	private let titleField: UITextField = {
		let field = UITextField()
		field.borderStyle = .none
		field.textColor = .white
		field.font = UIFont.systemFont(ofSize: 17, weight: .semibold)
		field.attributedPlaceholder = "title_placeholder".localized.firstUppercased.attributed(attributes: [.foregroundColor: UIColor.lightGray])
		field.keyboardAppearance = .dark
		return field
	}()

	// MARK: - initializers
	init(delegate: CreatePostViewDelegate) {
		super.init(frame: .zero)
		self.delegate = delegate
	}
	
	required init?(coder: NSCoder) {
		super.init(coder: coder)
	}

	// MARK: - methods
	func prepareView() {
		addSubview(titleField)
		addSubview(imageView)
		titleField.easy.layout(Top().to(safeAreaLayoutGuide, .top), Left(16), Right(16), Height(50))
		imageView.easy.layout(Top().to(titleField, .bottom), Left(), Right(), Height().like(imageView, .width))

		let taper = UITapGestureRecognizer(target: self, action: #selector(tapAction))
		addGestureRecognizer(taper)

		titleField.delegate = self
		titleField.becomeFirstResponder()
	}

	func set(image: ImageSource) {
		DispatchQueue.main.async {
			self.imageView.setImage(fromSource: image)
		}
	}

	func freeze() {
		titleField.isEnabled = false
		endEditing(true)
	}

	// MARK: - actions
	@objc private func tapAction() {
		endEditing(true)
	}
}

extension CreatePostView: UITextFieldDelegate {
	public func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
		let newText = NSString(string: textField.text!).replacingCharacters(in: range, with: string)
		delegate?.titleUpdated(text: String(newText))
		return true
	}
}

private func setupNavigationBar() {

      navigationItem.title = "home".localized.firstUppercased
      navigationItem.rightBarButtonItem = UIBarButtonItem(barButtonSystemItem: .add, target: self, action: #selector(addAction))

}

import UIKit
import Swinject
import ImageSource
import Paparazzo

class HomeNavigator: Navigator {
	private var resolver: Resolver!

	enum Destination {
		case createPost(imgItem: MediaPickerItem)
		case showPicker(completion: (_ items: [MediaPickerItem]) -> Void)
	}

	internal weak var sourceViewController: UIViewController?

	// MARK: - Initializer
	init(sourceViewController: UIViewController?, resolver: Resolver) {
		self.sourceViewController = sourceViewController
		self.resolver = resolver
	}

	// MARK: - Navigator
	func navigate(to destination: HomeNavigator.Destination) {
		if let destinationViewController = makeViewController(for: destination) {
			switch destination {
			case .showPicker:
				sourceViewController?.present(destinationViewController, animated: true, completion: nil)
			default:
				if let navVC = sourceViewController?.navigationController {
					navVC.pushViewController(destinationViewController, animated: true)
				}
			}
		}
	}
	
	// MARK: - Private
	internal func makeViewController(for destination: Destination) -> UIViewController? {
		switch destination {
		case .createPost(let item):
			if let vc = resolver.resolve(CreatePostViewType.self) as? CreatePostViewController {
				vc.presenter?.set(imageSource: item.image)
				return vc
			}
		case .showPicker(let completion):
			let viewController = PaparazzoFacade.paparazzoViewController(
				theme: PaparazzoUITheme(),
				parameters: MediaPickerData(
					items: [],
					maxItemsCount: 1
				),
				onFinish: { items in
					completion(items)
				}
			)
			return viewController
		}
		return nil
	}
}

navigator.navigate(to: .showPicker(completion: { [weak self] items in

            guard let item = items.first else { return }

            self?.navigator.navigate(to: .createPost(imgItem: item))

}))

import Foundation
import FirebaseFirestore
import FirebaseFirestoreSwift
import FirebaseStorage

protocol PostProvider: BaseProvider {
	func getCollection(completion: @escaping (_ collection: [Post], _ error: Error?) -> Void)
	func create(post: Post, completion: @escaping (_ error: Error?) -> Void)
}

final class PostProviderImpl: PostProvider {
	internal var collectionName = "posts"
	private let db = Firestore.firestore()

	func getCollection(completion: @escaping (_ collection: [Post], _ error: Error?) -> Void) {
		db.collection(collectionName)
			.order(by: Post.Fields.createdAt.rawValue, descending: true)
			.getDocuments { snapshot, error in
				guard nil == error else { completion([], error!); return }
				guard let snapshot = snapshot else { completion([], nil); return }
				let collection = snapshot.documents.compactMap { document -> Post? in
					guard var post = try? document.data(as: Post.self) else { return nil }
					guard let imageName = post.imageName else { return post }
					post.reference = Storage.storage().reference().child("images/\(imageName)")
					return post
				}
				completion(collection, nil)
		}
	}

	func create(post: Post, completion: @escaping (Error?) -> Void) {
		do {
			_ = try db.collection(collectionName).addDocument(from: post)
			completion(nil)
			return
		} catch {
			completion(error)
		}
	}
}

import Swinject

class ProvidersAssembly: Assembly {
	func assemble(container: Container) {
		container.register(PostProvider.self) { _ in
			PostProviderImpl()
		}
	}
}

private let assemblies: [Assembly] = [
	ServicesAssembly(),
	ProvidersAssembly(),
	GuestAssembly(),
	HomeAssembly(),
	CreatePostAssembly()
]

import Foundation
import RxSwift

protocol PostService {
	var trigger: PublishSubject<TriggerEvent> { get }
	func getPosts(completion: @escaping (_ posts: [Post], _ error: Error?) -> Void)
	func create(post: Post, completion: @escaping (_ error: Error?) -> Void)
}

final class PostServiceImpl: PostService {
	private var provider: PostProvider!
	private var storageService: StorageService!
	
	private(set) var trigger: PublishSubject<TriggerEvent> = PublishSubject<TriggerEvent>()

	init(provider: PostProvider, storageService: StorageService) {
		self.provider = provider
		self.storageService = storageService
	}

	func getPosts(completion: @escaping ([Post], Error?) -> Void) {
		provider.getCollection(completion: { (collection, error) in
			completion(collection, error)
		})
	}

	func create(post: Post, completion: @escaping (Error?) -> Void) {
		if let error = validate(post: post).first {
			return completion(error)
		}
		guard let imgData = post.image else { return completion(Post.ValidationError.imageEmpty) }
		imgData.fullResolutionImageData { data in
			guard let imgData = data else { return }
			self.storageService.create(data: imgData) { name, error in
				guard nil == error else { return completion(error) }
				var post = post
				post.imageName = name
				self.provider.create(post: post) { error in
					self.trigger.onNext(.saved)
					completion(error)
				}
			}
		}
	}

	// MARK: - private
	private func validate(post: Post) -> [Post.ValidationError] {
		var errors = [Post.ValidationError]()
		if post.title.isEmpty {
			errors.append(Post.ValidationError.titleEmpty)
		}
		if nil == post.image {
			errors.append(Post.ValidationError.imageEmpty)
		}
		if nil == post.userId {
			errors.append(Post.ValidationError.userIdEmpty)
		}
		return errors
	}
}

import Swinject

class ServicesAssembly: Assembly {
	func assemble(container: Container) {
		container.register(UserService.self) { _ in
			UserServiceImpl()
		}
		container.register(StorageService.self) { resolver in
			StorageServiceImpl(storageProvider: resolver.resolve(StorageProvider.self)!)
		}
		container.register(PostService.self) { resolver in
			PostServiceImpl(provider: resolver.resolve(PostProvider.self)!,
											storageService: resolver.resolve(StorageService.self)!)
		}.inObjectScope(.container)
	}
}